@arsedizioni/ars-utils 22.0.21 → 22.0.22

package/fesm2022/arsedizioni-ars-utils-core.mjs

@@ -1,2091 +1,2008 @@
 import * as i0 from '@angular/core';
-import { Pipe, inject, makeEnvironmentProviders, Injectable, ElementRef, afterNextRender, Directive, input, DestroyRef, HostListener, output, forwardRef, EventEmitter, signal, computed, Service, PLATFORM_ID, RendererFactory2 } from '@angular/core';
-import { parseISO, parse, format, getYear, getMonth, getDate, getDay, getDaysInMonth, addYears, addMonths, addDays, formatISO, isDate, isValid, endOfDay } from 'date-fns';
-import { it } from 'date-fns/locale';
-import { TZDate } from '@date-fns/tz';
-import { DomSanitizer } from '@angular/platform-browser';
+import { inject, Injectable, makeEnvironmentProviders, ElementRef, afterNextRender, Directive, input, DestroyRef, HostListener, output, forwardRef, effect, Pipe, EventEmitter, signal, computed, Service, PLATFORM_ID, RendererFactory2 } from '@angular/core';
 import { DateAdapter, MAT_DATE_LOCALE, MAT_DATE_FORMATS } from '@angular/material/core';
+import { TZDate } from '@date-fns/tz';
+import { getYear, getMonth, getDate, getDay, getDaysInMonth, parseISO, parse, format, addYears, addMonths, addDays, formatISO, isDate, isValid, endOfDay } from 'date-fns';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
-import { Subject, BehaviorSubject } from 'rxjs';
-import { debounceTime } from 'rxjs/operators';
+import { Subject, filter as filter$1, map as map$1, BehaviorSubject } from 'rxjs';
+import { debounceTime, filter, map } from 'rxjs/operators';
+import { it } from 'date-fns/locale';
 import { NG_VALIDATORS } from '@angular/forms';
+import { DomSanitizer } from '@angular/platform-browser';
 import { SelectionModel } from '@angular/cdk/collections';
 import { isPlatformBrowser } from '@angular/common';
 
 /**
- * Zero-dependency Markdown to HTML converter.
- *
- * Design goals:
- * - Single line-based pass over blocks (no repeated full-string regex passes).
- * - Inline formatting never touches code spans / code blocks (stash & restore).
- * - No HTML entity escaping by default in normal text: the source passes as-is.
- *   Exception: the content of code spans / code blocks is ALWAYS escaped, so
- *   things like List<string> render correctly (the browser displays the
- *   original characters; entities never reach the user or the clipboard).
- *   Opt-in full escaping via { escapeHtml: true } for untrusted input.
- * - URL sanitization on links/images (javascript:, vbscript:, data: are dropped).
- * - Bounded result cache for repeated renders (Angular change detection friendly).
- *
- * Supported syntax: headings, paragraphs, hard/soft breaks, hr, blockquotes
- * (nested), fenced code blocks, inline code, bold/italic/strikethrough, links
- * (with title), images, autolinked bare URLs, ordered/unordered lists (nested,
- * task lists, ordered start offset), GFM tables with alignment, raw HTML
- * blocks (e.g. <table>...</table>) passed through verbatim when escapeHtml
- * is false: their newlines stay plain newlines, never converted to <br>.
- *
- * Known simplifications (documented, by design):
- * - A blank line terminates a list.
- * - Setext headings (=== / ---) are not supported, use # syntax.
- * - Reference-style links [text][ref] are not supported.
+ * Creates an array of the given length, filling each slot with the result of `valueFunction`.
+ * @param length        - Number of elements to create.
+ * @param valueFunction - Factory called with each index to produce the element value.
+ * @returns Typed array of `length` elements.
  */
-class MarkdownUtils {
-    // #region Cache
-    static { this.cache = new Map(); }
-    static { this.CACHE_MAX = 200; }
-    /** Clears the internal result cache. */
-    static clearCache() {
-        this.cache.clear();
+function range(length, valueFunction) {
+    const valuesArray = Array(length);
+    for (let i = 0; i < length; i++) {
+        valuesArray[i] = valueFunction(i);
     }
-    // #endregion
-    // #region Public API
-    /**
-     * Convert markdown to HTML.
-     * @param markdown : the markdown source
-     * @param options  : conversion options
-     * @returns        : the HTML string ('' when input is falsy)
-     */
-    static toHtml(markdown, options) {
-        if (!markdown)
-            return '';
-        const opts = { escapeHtml: false, breaks: true, ...options };
-        const key = `${opts.escapeHtml ? 1 : 0}${opts.breaks ? 1 : 0}|${markdown}`;
-        const hit = this.cache.get(key);
-        if (hit !== undefined)
-            return hit;
-        // Normalize line endings and fix glued sentence punctuation ("dettaglio!Ecco")
-        const source = markdown
-            .replace(/\r\n?/g, '\n')
-            .replace(/([A-Za-zÀ-ÿ][!?])([A-Za-zÀ-ÿ])/g, '$1 $2');
-        const html = this.parseBlocks(source.split('\n'), opts).trim();
-        if (this.cache.size >= this.CACHE_MAX) {
-            this.cache.delete(this.cache.keys().next().value); // FIFO eviction
+    return valuesArray;
+}
+// date-fns doesn't have a way to read/print month names or days of the week directly,
+// so we get them by formatting a date with a format that produces the desired month/day.
+const MONTH_FORMATS = {
+    long: 'LLLL',
+    short: 'LLL',
+    narrow: 'LLLLL',
+};
+const DAY_OF_WEEK_FORMATS = {
+    long: 'EEEE',
+    short: 'EEE',
+    narrow: 'EEEEE',
+};
+const MAT_DATE_FNS_FORMATS = {
+    parse: {
+        dateInput: 'P',
+    },
+    display: {
+        dateInput: 'P',
+        monthYearLabel: 'LLL uuuu',
+        dateA11yLabel: 'PP',
+        monthYearA11yLabel: 'LLLL uuuu',
+    },
+};
+/**
+ * date-fns adapter that integrates Angular Material's date picker with the date-fns library,
+ * applying `Europe/Rome` timezone for all parsed and created dates.
+ */
+class DateFnsAdapter extends DateAdapter {
+    constructor() {
+        super();
+        const matDateLocale = inject(MAT_DATE_LOCALE, { optional: true });
+        // MAT_DATE_LOCALE defaults to LOCALE_ID (a string): only a date-fns
+        // Locale OBJECT is usable here, a string would break format()/parse().
+        if (matDateLocale && typeof matDateLocale === 'object') {
+            this.setLocale(matDateLocale);
         }
-        this.cache.set(key, html);
-        return html;
     }
-    // #endregion
-    // #region Block parser (single pass)
-    /** Block-level HTML tags that start a raw HTML block (passthrough, no <p>/<br>). */
-    static { this.htmlBlockTags = new Set([
-        'address', 'article', 'aside', 'blockquote', 'caption', 'colgroup', 'col',
-        'dd', 'details', 'dialog', 'div', 'dl', 'dt', 'fieldset', 'figcaption',
-        'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header',
-        'hr', 'iframe', 'li', 'main', 'nav', 'ol', 'p', 'pre', 'section', 'summary',
-        'table', 'tbody', 'td', 'tfoot', 'thead', 'th', 'tr', 'ul',
-    ]); }
-    /** Void/self-contained tags: a single tag, no closing tag expected. */
-    static { this.htmlVoidTags = new Set(['hr', 'col', 'img', 'input']); }
     /**
-     * Precompiled: first block-level tag occurrence anywhere in a line.
-     * Anchored on the '<' literal, so scanning is cheap; the lookahead
-     * prevents partial matches ('<td' must not match inside '<tdx').
+     * Returns the year component of the given date.
+     * @param date - The source date.
      */
-    static { this.htmlBlockScanRe = new RegExp(`<(\\/?)(${[...MarkdownUtils.htmlBlockTags].join('|')})(?=[\\s/>])`, 'gi'); }
-    /** Result of scanning a line for the start of a raw HTML block. */
-    static findHtmlBlockStart(line) {
-        // HTML comment candidate (skipping occurrences inside inline code spans)
-        let comment = line.indexOf('<!--');
-        while (comment !== -1 && this.insideCodeSpan(line, comment)) {
-            comment = line.indexOf('<!--', comment + 4);
-        }
-        // Block tag candidate (same code-span guard)
-        const re = this.htmlBlockScanRe;
-        re.lastIndex = 0;
-        let m;
-        let tagHit;
-        while ((m = re.exec(line)) !== null) {
-            if (!this.insideCodeSpan(line, m.index)) {
-                tagHit = { index: m.index, tag: m[2].toLowerCase(), isClose: m[1] === '/' };
-                break;
-            }
-        }
-        if (comment !== -1 && (!tagHit || comment < tagHit.index)) {
-            return { index: comment, tag: '', isClose: false, isComment: true };
-        }
-        return tagHit ? { ...tagHit, isComment: false } : undefined;
+    getYear(date) {
+        return getYear(date);
     }
-    /** True when `index` falls inside an inline code span (odd backtick count before it). */
-    static insideCodeSpan(line, index) {
-        let count = 0;
-        for (let i = 0; i < index; i++) {
-            if (line.charCodeAt(i) === 96 /* ` */)
-                count++;
-        }
-        return (count & 1) === 1;
+    /**
+     * Returns the zero-based month index of the given date (0 = January).
+     * @param date - The source date.
+     */
+    getMonth(date) {
+        return getMonth(date);
     }
     /**
-     * indexOf-based depth scanner (no regex, no allocations): walks `text`
-     * adjusting `depth` for <tag ...> / </tag> occurrences of the SAME tag.
-     * Self-closing <tag ... /> forms do not alter depth.
-     * @returns [newDepth, endIndex] where endIndex is the position right after
-     *          the '>' that balanced the element, or -1 when still open.
+     * Returns the day-of-month of the given date (1-based).
+     * @param date - The source date.
      */
-    static scanHtmlDepth(text, tag, depth) {
-        const lower = text.toLowerCase();
-        const open = '<' + tag;
-        const close = '</' + tag;
-        let i = 0;
-        while ((i = lower.indexOf('<', i)) !== -1) {
-            if (lower.startsWith(close, i) && this.isTagBoundary(lower, i + close.length)) {
-                depth--;
-                const gt = lower.indexOf('>', i);
-                const end = gt === -1 ? lower.length : gt + 1;
-                if (depth <= 0)
-                    return [0, end];
-                i = end;
-            }
-            else if (lower.startsWith(open, i) && this.isTagBoundary(lower, i + open.length)) {
-                const gt = lower.indexOf('>', i);
-                const selfClosing = gt !== -1 && lower.charCodeAt(gt - 1) === 47 /* / */;
-                if (selfClosing) {
-                    if (depth === 0)
-                        return [0, gt + 1]; // standalone self-closed element
-                }
-                else {
-                    depth++;
-                }
-                i = gt === -1 ? lower.length : gt + 1;
-            }
-            else {
-                i++;
-            }
-        }
-        return [depth, -1];
+    getDate(date) {
+        return getDate(date);
     }
-    /** A tag token must be followed by whitespace, '/', '>' or end of line. */
-    static isTagBoundary(s, idx) {
-        if (idx >= s.length)
-            return true; // tag opening continues on the next line
-        const c = s.charCodeAt(idx);
-        return c === 62 /* > */ || c === 47 /* / */ || c === 32 /* space */ || c === 9 /* tab */;
+    /**
+     * Returns the day-of-week of the given date (0 = Sunday).
+     * @param date - The source date.
+     */
+    getDayOfWeek(date) {
+        return getDay(date);
     }
     /**
-     * Re-injects the remainder of a partially consumed line so the main loop
-     * processes it as markdown. Returns the index the loop should resume from.
+     * Returns an array of 12 month name strings formatted for the active locale.
+     * @param style - One of `'long'`, `'short'`, or `'narrow'`.
      */
-    static pushBack(lines, i, remainder) {
-        if (remainder.trim()) {
-            lines[i] = remainder;
-            return i - 1; // the loop's i++ re-processes the remainder
-        }
-        return i;
+    getMonthNames(style) {
+        const pattern = MONTH_FORMATS[style];
+        return range(12, i => this.format(new Date(2017, i, 1), pattern));
     }
     /**
-     * Emits a raw HTML block starting at `hit.index` of lines[i], consuming
-     * following lines until the element is balanced. Text after the block on
-     * the closing line is pushed back for markdown processing.
-     * @returns the index of the last consumed line
+     * Returns an array of 31 day-of-month label strings formatted using `Intl.DateTimeFormat`
+     * when available, falling back to plain numeric strings.
      */
-    static emitHtmlBlock(lines, i, hit, out) {
-        const line = lines[i];
-        // HTML comment: raw until '-->'
-        if (hit.isComment) {
-            let end = line.indexOf('-->', hit.index);
-            if (end !== -1) {
-                out.push(line.slice(hit.index, end + 3));
-                return this.pushBack(lines, i, line.slice(end + 3));
+    getDateNames() {
+        const dtf = typeof Intl !== 'undefined'
+            ? new Intl.DateTimeFormat(this.locale?.code, {
+                day: 'numeric',
+                timeZone: 'utc',
+            })
+            : null;
+        return range(31, i => {
+            if (dtf) {
+                // date-fns doesn't appear to support this functionality.
+                // Fall back to `Intl` on supported browsers.
+                const date = new Date();
+                date.setUTCFullYear(2017, 0, i + 1);
+                date.setUTCHours(0, 0, 0, 0);
+                return dtf.format(date).replace(/[\u200e\u200f]/g, '');
             }
-            out.push(line.slice(hit.index));
-            while (++i < lines.length) {
-                end = lines[i].indexOf('-->');
-                if (end !== -1) {
-                    out.push(lines[i].slice(0, end + 3));
-                    return this.pushBack(lines, i, lines[i].slice(end + 3));
-                }
-                out.push(lines[i]);
-            }
-            return lines.length - 1; // unterminated: consumed to EOF
-        }
-        // Stray closing tag or void tag: emit just the tag, resume after '>'
-        if (hit.isClose || this.htmlVoidTags.has(hit.tag)) {
-            const gt = line.indexOf('>', hit.index);
-            const end = gt === -1 ? line.length : gt + 1;
-            out.push(line.slice(hit.index, end));
-            return this.pushBack(lines, i, line.slice(end));
+            return String(i + 1);
+        });
+    }
+    /**
+     * Returns an array of 7 day-of-week name strings formatted for the active locale.
+     * @param style - One of `'long'`, `'short'`, or `'narrow'`.
+     */
+    getDayOfWeekNames(style) {
+        const pattern = DAY_OF_WEEK_FORMATS[style];
+        return range(7, i => this.format(new Date(2017, 0, i + 1), pattern));
+    }
+    /**
+     * Returns the four-digit year string for the given date.
+     * @param date - The source date.
+     */
+    getYearName(date) {
+        return this.format(date, 'y');
+    }
+    /**
+     * Returns the first day of the week for the active locale (0 = Sunday, 1 = Monday, …).
+     */
+    getFirstDayOfWeek() {
+        return this.locale?.options?.weekStartsOn ?? 0;
+    }
+    /**
+     * Returns the number of days in the month of the given date.
+     * @param date - The source date.
+     */
+    getNumDaysInMonth(date) {
+        return getDaysInMonth(date);
+    }
+    /**
+     * Creates an independent copy of the given date.
+     * @param date - The date to clone.
+     */
+    clone(date) {
+        return new Date(date.getTime());
+    }
+    /**
+     * Creates a `Date` in the `Europe/Rome` timezone for the given year, month, and day.
+     * Throws an `Error` when any component is out of range.
+     * @param year  - Full four-digit year.
+     * @param month - Zero-based month index (0 = January, 11 = December).
+     * @param date  - Day-of-month (1-based).
+     */
+    createDate(year, month, date) {
+        if (month < 0 || month > 11) {
+            throw Error(`Invalid month index "${month}". Month index has to be between 0 and 11.`);
         }
-        // Opening block tag: raw until the element is balanced (depth === 0)
-        let [depth, split] = this.scanHtmlDepth(line.slice(hit.index), hit.tag, 0);
-        if (split !== -1) {
-            out.push(line.slice(hit.index, hit.index + split));
-            return this.pushBack(lines, i, line.slice(hit.index + split));
+        if (date < 1) {
+            throw Error(`Invalid date "${date}". Date has to be greater than 0.`);
         }
-        out.push(line.slice(hit.index));
-        while (depth > 0 && ++i < lines.length) {
-            [depth, split] = this.scanHtmlDepth(lines[i], hit.tag, depth);
-            if (split !== -1) {
-                out.push(lines[i].slice(0, split));
-                return this.pushBack(lines, i, lines[i].slice(split));
-            }
-            out.push(lines[i]);
+        // Passing the year to the constructor causes year numbers <100 to be converted to 19xx.
+        // To work around this we use `setFullYear` and `setHours` instead.
+        const result = new Date();
+        result.setFullYear(year, month, date);
+        result.setHours(0, 0, 0, 0);
+        const result2 = new TZDate(result, 'Europe/Rome');
+        if (result2.getMonth() !== month) {
+            throw Error(`Invalid date "${date}" for month with index "${month}".`);
         }
-        return Math.min(i, lines.length - 1);
+        return result2;
     }
-    static parseBlocks(lines, opts) {
-        const out = [];
-        let paragraph = [];
-        const flush = () => {
-            if (paragraph.length > 0) {
-                const sep = opts.breaks ? '<br>' : ' ';
-                out.push(`<p>${paragraph.map(l => this.inline(l, opts)).join(sep)}</p>`);
-                paragraph = [];
-            }
-        };
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const trimmed = line.trim();
-            // --- Fenced code block -------------------------------------------------
-            const fence = trimmed.match(/^```([\w+-]+)?\s*$/);
-            if (fence) {
-                flush();
-                const lang = fence[1] ? ` class="language-${fence[1]}"` : '';
-                const code = [];
-                i++;
-                while (i < lines.length && !/^```\s*$/.test(lines[i].trim())) {
-                    code.push(lines[i]);
-                    i++;
-                }
-                out.push(`<pre><code${lang}>${this.escape(code.join('\n'))}</code></pre>`);
-                continue;
-            }
-            // --- Blank line --------------------------------------------------------
-            if (!trimmed) {
-                flush();
-                continue;
-            }
-            // --- Raw HTML block passthrough (only with escaping disabled) ------------
-            // A block-level HTML element found ANYWHERE in the line starts a raw
-            // block: text before it joins the current paragraph, the element is
-            // emitted as-is (plain newlines, no <p>, no <br>) until balanced, and
-            // any text after the closing tag resumes markdown processing.
-            if (!opts.escapeHtml && line.includes('<')) {
-                const hit = this.findHtmlBlockStart(line);
-                if (hit) {
-                    const before = line.slice(0, hit.index).trim();
-                    if (before)
-                        paragraph.push(before);
-                    flush();
-                    i = this.emitHtmlBlock(lines, i, hit, out);
-                    continue;
-                }
-            }
-            // --- ATX heading -------------------------------------------------------
-            const heading = trimmed.match(/^(#{1,6})\s+(.+?)\s*#*\s*$/);
-            if (heading) {
-                flush();
-                const level = heading[1].length;
-                out.push(`<h${level}>${this.inline(heading[2], opts)}</h${level}>`);
-                continue;
-            }
-            // --- Horizontal rule ---------------------------------------------------
-            if (/^(?:-{3,}|\*{3,}|_{3,})$/.test(trimmed)) {
-                flush();
-                out.push('<hr>');
-                continue;
+    /**
+     * Returns today's date in the local timezone.
+     */
+    today() {
+        return new Date();
+    }
+    /**
+     * Parses a value into a `Date`.
+     * - Strings are first attempted as ISO 8601, then matched against each format in `parseFormat`.
+     * - Numbers are treated as Unix timestamps (milliseconds).
+     * - Existing `Date` instances are cloned.
+     * @param value       - The value to parse.
+     * @param parseFormat - A format string or an array of format strings (date-fns tokens).
+     * @returns A valid `Date` in `Europe/Rome`, an invalid sentinel, or `null` for unrecognised input.
+     */
+    parse(value, parseFormat) {
+        if (typeof value === 'string' && value.length > 0) {
+            const iso8601Date = parseISO(value);
+            if (this.isValid(iso8601Date)) {
+                return new TZDate(iso8601Date, 'Europe/Rome');
             }
-            // --- Blockquote (consecutive lines, one level stripped, recursive) ------
-            if (/^>\s?/.test(trimmed)) {
-                flush();
-                const quoted = [];
-                while (i < lines.length && /^>\s?/.test(lines[i].trim())) {
-                    quoted.push(lines[i].trim().replace(/^>\s?/, ''));
-                    i++;
-                }
-                i--;
-                out.push(`<blockquote>${this.parseBlocks(quoted, opts)}</blockquote>`);
-                continue;
+            const formats = Array.isArray(parseFormat) ? parseFormat : [parseFormat];
+            if (!formats.length) {
+                throw Error('Formats array must not be empty.');
             }
-            // --- Table (header row + separator row) ---------------------------------
-            if (trimmed.includes('|') &&
-                i + 1 < lines.length &&
-                lines[i + 1].includes('-') &&
-                /^\|?[\s:\-|]+\|?$/.test(lines[i + 1].trim())) {
-                flush();
-                const aligns = this.tableAligns(lines[i + 1].trim());
-                const head = this.tableRow(trimmed, 'th', aligns, opts);
-                const body = [];
-                i += 2;
-                while (i < lines.length && lines[i].trim().includes('|')) {
-                    body.push(this.tableRow(lines[i].trim(), 'td', aligns, opts));
-                    i++;
+            for (const currentFormat of formats) {
+                const fromFormat = parse(value, currentFormat, new Date(), { locale: this.locale });
+                if (this.isValid(fromFormat)) {
+                    return new TZDate(fromFormat, 'Europe/Rome');
                 }
-                i--;
-                out.push(`<table>\n<thead>\n${head}\n</thead>` +
-                    (body.length > 0 ? `\n<tbody>\n${body.join('\n')}\n</tbody>` : '') +
-                    `\n</table>`);
-                continue;
-            }
-            // --- List ---------------------------------------------------------------
-            if (MarkdownUtils.listItemRe.test(line)) {
-                flush();
-                const [html, last] = this.parseList(lines, i, opts);
-                out.push(html);
-                i = last;
-                continue;
             }
-            // --- Plain text: accumulate into current paragraph ----------------------
-            paragraph.push(trimmed);
+            return this.invalid();
         }
-        flush();
-        return out.join('\n');
+        else if (typeof value === 'number') {
+            return new Date(value);
+        }
+        else if (value instanceof Date) {
+            return this.clone(value);
+        }
+        return null;
     }
-    // #endregion
-    // #region Lists
-    /** Matches "- item", "* item", "+ item", "1. item", "1) item" with leading indent. */
-    static { this.listItemRe = /^(\s*)([-*+]|\d+[.)])\s+(.*)$/; }
     /**
-     * Gathers the contiguous list block starting at `start`, builds it (with
-     * nesting) and returns [html, indexOfLastConsumedLine].
+     * Formats a `Date` using the given date-fns display format string.
+     * Throws an `Error` when `date` is not valid.
+     * @param date          - The date to format.
+     * @param displayFormat - A date-fns format string (e.g. `'P'`, `'LLL uuuu'`).
      */
-    static parseList(lines, start, opts) {
-        const block = [];
-        let i = start;
-        while (i < lines.length) {
-            const l = lines[i];
-            if (!l.trim())
-                break; // blank line ends the list
-            if (this.listItemRe.test(l) || /^\s{2,}\S/.test(l)) {
-                block.push(l);
-                i++;
-            }
-            else
-                break;
+    format(date, displayFormat) {
+        if (!this.isValid(date)) {
+            throw Error('DateFnsAdapter: Cannot format invalid date.');
         }
-        return [this.buildList(block, opts), i - 1];
+        return format(date, displayFormat, { locale: this.locale });
     }
-    static buildList(block, opts) {
-        const first = block[0].match(this.listItemRe);
-        const baseIndent = first[1].length;
-        const ordered = /^\d/.test(first[2]);
-        const startNum = ordered ? parseInt(first[2], 10) : 1;
-        const items = [];
-        for (const l of block) {
-            const m = l.match(this.listItemRe);
-            if (m && m[1].length <= baseIndent) {
-                items.push({ text: m[3], childLines: [] });
-            }
-            else if (items.length > 0) {
-                // Continuation or nested content: strip one nesting level of indent
-                items[items.length - 1].childLines.push(l.length > baseIndent + 2 ? l.slice(baseIndent + 2) : l.trim());
-            }
-        }
-        const lis = items.map(item => {
-            let inner;
-            // GFM task list: - [ ] / - [x]
-            const task = item.text.match(/^\[([ xX])\]\s+(.*)$/);
-            if (task) {
-                const checked = task[1] !== ' ' ? ' checked' : '';
-                inner = `<input type="checkbox" disabled${checked}> ${this.inline(task[2], opts)}`;
-            }
-            else {
-                inner = this.inline(item.text, opts);
-            }
-            if (item.childLines.length > 0) {
-                inner += '\n' + this.parseBlocks(item.childLines, opts);
-            }
-            return `<li>${inner}</li>`;
-        });
-        const tag = ordered ? 'ol' : 'ul';
-        const startAttr = ordered && startNum > 1 ? ` start="${startNum}"` : '';
-        return `<${tag}${startAttr}>\n${lis.join('\n')}\n</${tag}>`;
-    }
-    // #endregion
-    // #region Tables
-    static tableAligns(separator) {
-        return separator
-            .replace(/^\||\|$/g, '')
-            .split('|')
-            .map(cell => {
-            const t = cell.trim();
-            if (t.startsWith(':') && t.endsWith(':'))
-                return 'center';
-            if (t.endsWith(':'))
-                return 'right';
-            if (t.startsWith(':'))
-                return 'left';
-            return undefined;
-        });
-    }
-    static tableRow(row, tag, aligns, opts) {
-        const cells = row.replace(/^\||\|$/g, '').split('|').map(c => c.trim());
-        const cellsHtml = cells
-            .map((cell, j) => {
-            const align = aligns[j] ? ` align="${aligns[j]}"` : '';
-            return `<${tag}${align}>${this.inline(cell, opts)}</${tag}>`;
-        })
-            .join('');
-        return `<tr>${cellsHtml}</tr>`;
+    /**
+     * Adds the given number of whole years to a date.
+     * @param date  - The base date.
+     * @param years - Number of years to add (can be negative).
+     */
+    addCalendarYears(date, years) {
+        return addYears(date, years);
     }
-    // #endregion
-    // #region Inline formatting
     /**
-     * Applies inline markdown to a single text segment.
-     * Generated HTML (code, links, images, autolinks) is stashed behind \u0000
-     * placeholders so later regex passes can never corrupt it.
+     * Adds the given number of whole months to a date.
+     * @param date   - The base date.
+     * @param months - Number of months to add (can be negative).
      */
-    static inline(text, opts) {
-        const store = [];
-        const stash = (html) => `\u0000${store.push(html) - 1}\u0000`;
-        // 1. Inline code: stash first so later passes can't touch it.
-        //    Content is ALWAYS escaped so <, >, & inside code survive in the DOM
-        //    (the browser renders entities back to the original characters).
-        let s = text.replace(/`([^`]+)`/g, (_m, code) => stash(`<code>${this.escape(code)}</code>`));
-        // 2. Escape raw HTML as entities (opt-in only)
-        if (opts.escapeHtml)
-            s = this.escape(s);
-        // 3. Images: ![alt](url "title")
-        s = s.replace(/!\[([^\]]*)\]\(\s*([^)\s]+)(?:\s+(?:"|&quot;)(.+?)(?:"|&quot;))?\s*\)/g, (_m, alt, src, title) => {
-            const url = this.safeUrl(src);
-            if (!url)
-                return alt;
-            const t = title ? ` title="${title}"` : '';
-            return stash(`<img src="${url}" alt="${alt}"${t} loading="lazy">`);
-        });
-        // 4. Links: [text](url "title")
-        s = s.replace(/\[([^\]]+)\]\(\s*([^)\s]+)(?:\s+(?:"|&quot;)(.+?)(?:"|&quot;))?\s*\)/g, (_m, txt, href, title) => {
-            const url = this.safeUrl(href);
-            if (!url)
-                return txt;
-            const t = title ? ` title="${title}"` : '';
-            return stash(`<a href="${url}"${t} target="_blank" rel="noopener noreferrer">${txt}</a>`);
-        });
-        // 5. Autolink remaining bare URLs (markdown links are already stashed)
-        s = s.replace(/https?:\/\/[^\s<>"']+/g, url => stash(`<a href="${url}" target="_blank" rel="noopener noreferrer">${url}</a>`));
-        // 6. Bold / italic / strikethrough.
-        //    Delimiters must hug the text; underscore emphasis only at word
-        //    boundaries so identifiers like snake_case are left untouched.
-        s = s.replace(/\*\*\*(?=\S)([\s\S]*?\S)\*\*\*/g, '<strong><em>$1</em></strong>');
-        s = s.replace(/(?<![\w*])___(?=\S)([\s\S]*?\S)___(?![\w*])/g, '<strong><em>$1</em></strong>');
-        s = s.replace(/\*\*(?=\S)([\s\S]*?\S)\*\*/g, '<strong>$1</strong>');
-        s = s.replace(/(?<![\w*])__(?=\S)([\s\S]*?\S)__(?![\w*])/g, '<strong>$1</strong>');
-        s = s.replace(/\*(?=\S)([^*\n]*?\S)\*/g, '<em>$1</em>');
-        s = s.replace(/(?<![\w_])_(?=\S)([^_\n]*?\S)_(?![\w_])/g, '<em>$1</em>');
-        s = s.replace(/~~(?=\S)([\s\S]*?\S)~~/g, '<del>$1</del>');
-        // 7. Restore stashed HTML
-        return s.replace(/\u0000(\d+)\u0000/g, (_m, idx) => store[Number(idx)] ?? '');
+    addCalendarMonths(date, months) {
+        return addMonths(date, months);
     }
-    // #endregion
-    // #region Security helpers
-    /** Escapes &, <, > and " for safe HTML interpolation. */
-    static escape(s) {
-        return s
-            .replace(/&/g, '&amp;')
-            .replace(/</g, '&lt;')
-            .replace(/>/g, '&gt;')
-            .replace(/"/g, '&quot;');
+    /**
+     * Adds the given number of whole days to a date.
+     * @param date - The base date.
+     * @param days - Number of days to add (can be negative).
+     */
+    addCalendarDays(date, days) {
+        return addDays(date, days);
     }
     /**
-     * Returns a sanitized URL or undefined when the scheme is dangerous.
-     * Blocks javascript:, vbscript: and data: (also when obfuscated with
-     * whitespace/control characters, e.g. "java\tscript:").
+     * Serialises a date to an ISO 8601 date string (`yyyy-MM-dd`).
+     * @param date - The date to serialise.
      */
-    static safeUrl(url) {
-        const compact = url.replace(/[\s\u0000-\u001f]/g, '');
-        if (/^(javascript|vbscript|data):/i.test(compact))
-            return undefined;
-        return url.replace(/"/g, '%22');
+    toIso8601(date) {
+        return formatISO(date, { representation: 'date' });
     }
-    // #endregion
-    // #region Clipboard
     /**
-     * Copies markdown content to the clipboard in two flavors:
-     * - text/html  : the rendered HTML (rich paste into Word, Outlook, Gmail...)
-     * - text/plain : the original markdown source (paste into editors, IDEs...)
-     * @param markdown : the markdown source
-     * @param options  : conversion options for the HTML flavor
-     * @returns        : true on success
+     * Returns the given value when it is a valid `Date`, or `null` for an empty string.
+     * Deserialises valid ISO 8601 strings into `Date` instances.
+     * Delegates all other values to the base-class implementation.
+     * @param value - The raw value to deserialise.
      */
-    static async copyToClipboard(markdown, options) {
-        if (!markdown || typeof navigator === 'undefined' || !navigator.clipboard)
-            return false;
-        try {
-            if (typeof ClipboardItem !== 'undefined') {
-                const html = this.toHtml(markdown, options);
-                await navigator.clipboard.write([
-                    new ClipboardItem({
-                        'text/html': new Blob([html], { type: 'text/html' }),
-                        'text/plain': new Blob([markdown], { type: 'text/plain' }),
-                    }),
-                ]);
+    deserialize(value) {
+        if (typeof value === 'string') {
+            if (!value) {
+                return null;
             }
-            else {
-                // Older engines: plain text only
-                await navigator.clipboard.writeText(markdown);
+            const date = parseISO(value);
+            if (this.isValid(date)) {
+                return date;
             }
-            return true;
-        }
-        catch {
-            // Clipboard API requires a secure context and user activation
-            return false;
         }
+        return super.deserialize(value);
     }
     /**
-     * Copies plain text (e.g. the content of a single code block) to the clipboard.
-     * @param text : the text to copy
-     * @returns    : true on success
+     * Returns `true` when `obj` is an instance of `Date`.
+     * @param obj - The object to test.
      */
-    static async copyText(text) {
-        if (!text || typeof navigator === 'undefined' || !navigator.clipboard)
-            return false;
-        try {
-            await navigator.clipboard.writeText(text);
-            return true;
-        }
-        catch {
-            return false;
-        }
+    isDateInstance(obj) {
+        return isDate(obj);
     }
     /**
-     * Extracts the visible plain text from a rendered element
-     * (what the user sees, entities already decoded by the browser).
-     * @param element : the element hosting the rendered markdown
-     * @returns       : the plain text
+     * Returns `true` when `date` represents a valid point in time.
+     * @param date - The date to validate.
      */
-    static elementToText(element) {
-        return element.innerText ?? element.textContent ?? '';
+    isValid(date) {
+        return isValid(date);
     }
-}
-
-var DateFormat;
-(function (DateFormat) {
-    DateFormat[DateFormat["Short"] = 1] = "Short";
-    DateFormat[DateFormat["Long"] = 2] = "Long";
-    DateFormat[DateFormat["LongWithShortMonth"] = 3] = "LongWithShortMonth";
-    DateFormat[DateFormat["LongWithWeekDay"] = 4] = "LongWithWeekDay";
-    DateFormat[DateFormat["LongWithShortWeekDay"] = 5] = "LongWithShortWeekDay";
-    DateFormat[DateFormat["MonthAndYear"] = 6] = "MonthAndYear";
-    DateFormat[DateFormat["LongMonthAndYear"] = 7] = "LongMonthAndYear";
-    DateFormat[DateFormat["WeekDay"] = 8] = "WeekDay";
-    DateFormat[DateFormat["LongWeekDay"] = 9] = "LongWeekDay";
-    DateFormat[DateFormat["DayAndMonth"] = 10] = "DayAndMonth";
-    DateFormat[DateFormat["ShortUS"] = 11] = "ShortUS";
-    DateFormat[DateFormat["ShortISO8601"] = 12] = "ShortISO8601"; // yyyy-mm-dd
-})(DateFormat || (DateFormat = {}));
-class SystemUtils {
-    /** Shared collator for locale-aware, case-insensitive string comparison. */
-    static { this.collator = new Intl.Collator('it', { sensitivity: 'base', numeric: true }); }
     /**
-     * Array find by key
-     * @param array     : the array to scan
-     * @param key       : key name
-     * @param value     : the value to search for
-     * @returns         : the property value or null
+     * Returns a sentinel `Date` that represents an invalid date (`new Date(NaN)`).
      */
-    static arrayFindByKey(array, key, value) {
-        if (!array)
-            return undefined;
-        for (const item of array) {
-            if (item[key] === value) {
-                return item;
-            }
-        }
-        return undefined;
+    invalid() {
+        return new Date(NaN);
     }
-    /**
-     * Array find index by key
-     * @param array   : the array to scan
-     * @param key     : the key name
-     * @param value   : the value to search for
-     * @returns       : the array index or -1 if not found
-     */
-    static arrayFindIndexByKey(array, key, value) {
-        if (!array)
-            return -1;
-        for (let i = 0; i < array.length; i++) {
-            if (array[i][key] === value) {
-                return i;
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: DateFnsAdapter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: DateFnsAdapter }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: DateFnsAdapter, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+/**
+ * Standalone providers for the scm-utils date-fns adapter.
+ *
+ * Configures Angular Material to use {@link DateFnsAdapter} (Europe/Rome timezone)
+ * and the matching {@link MAT_DATE_FNS_FORMATS}.
+ *
+ * @example
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideSCMDateFns()]
+ * });
+ */
+function provideSCMDateFns() {
+    return makeEnvironmentProviders([
+        {
+            provide: DateAdapter,
+            useClass: DateFnsAdapter,
+            deps: [MAT_DATE_LOCALE],
+        },
+        { provide: MAT_DATE_FORMATS, useValue: MAT_DATE_FNS_FORMATS }
+    ]);
+}
+
+/**
+ * Directive that moves browser focus to the host element after the first render cycle.
+ * Apply `autoFocus` to any focusable element to set focus automatically on initialisation.
+ */
+class AutoFocusDirective {
+    constructor() {
+        this.elementRef = inject(ElementRef);
+        afterNextRender(() => {
+            this.elementRef.nativeElement?.focus();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: AutoFocusDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.1", type: AutoFocusDirective, isStandalone: true, selector: "[autoFocus]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: AutoFocusDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[autoFocus]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [] });
+
+class FileInfo {
+    isValid() {
+        return this.valid;
+    }
+}
+class ValueModel {
+}
+class IDModel {
+}
+class GroupModel {
+}
+class DeleteModel extends GroupModel {
+}
+class RelationModel {
+}
+class UpdateRelationsModel {
+}
+class QueryModel {
+}
+class ImportModel {
+}
+class DateInterval {
+    get fromAsDate() {
+        if (this.from) {
+            if (!(this.from instanceof Date)) {
+                this.from = new Date(this.from);
+            }
+            if (this.from) {
+                return new Date(this.from.getFullYear(), this.from.getMonth(), this.from.getDate(), 2, 0, 0);
             }
         }
-        return -1;
+        return undefined;
     }
-    /**
-     * Get a value from and array made of name|value items
-     * @param array   : the array to scan
-     * @param value   : the value to search for
-     * @returns       : the property value or null if not found
-     */
-    static arrayGetValue(array, value) {
-        if (!array)
-            return undefined;
-        for (const item of array) {
-            const i = item;
-            if (i['value'] === value) {
-                return i['name'] ?? i['id'];
+    get toAsDate() {
+        if (this.to) {
+            if (!(this.to instanceof Date)) {
+                this.to = new Date(this.to);
+            }
+            if (this.to) {
+                return new Date(this.to.getFullYear(), this.to.getMonth(), this.to.getDate(), 2, 0, 0);
             }
         }
         return undefined;
     }
-    /**
-     * Convert items to nodes into a tree structure
-     * @param items   : list of nodes
-     * @param parent  : parent node
-     * @returns       : an array of INode objects
-     */
-    static arrayToNodes(items, parent) {
-        const nodes = [];
-        items.forEach(n => {
-            const node = {
-                id: n.id.toString(),
-                name: n.name,
-                count: n.count ? n.count : 0,
-                children: undefined,
-                parent,
-                bag: n,
-            };
-            nodes.push(node);
-            node.children =
-                n.children && n.children.length > 0
-                    ? this.arrayToNodes(n.children, node)
-                    : [];
-        });
-        return nodes;
-    }
-    /**
-     * Comparator factory for sorting arrays of objects by a given property key.
-     * @param key   - Name of the property to sort by.
-     * @param order - Sort direction: `'asc'` (default) or `'desc'`.
-     * @returns A comparator function that returns a negative, zero, or positive number.
-     */
-    static arraySortCompare(key, order = 'asc') {
-        const dir = order === 'desc' ? -1 : 1;
-        return (a, b) => {
-            const varA = a[key];
-            const varB = b[key];
-            if (varA === varB)
-                return 0;
-            if (varA === undefined || varA === null)
-                return -1 * dir;
-            if (varB === undefined || varB === null)
-                return 1 * dir;
-            if (typeof varA === 'string' && typeof varB === 'string') {
-                return SystemUtils.collator.compare(varA, varB) * dir;
-            }
-            return (varA > varB ? 1 : varA < varB ? -1 : 0) * dir;
-        };
+    constructor(from, to) {
+        this.from = from;
+        this.to = to;
     }
-    /**
-     * Format weight
-     * @param gr    : grams
-     * @returns     : the formatted string
-     */
-    static formatWeight(gr) {
-        if (gr > 1000000)
-            return `${(gr / 1000000).toFixed(2)} t`;
-        else if (gr > 100000)
-            return `${(gr / 100000).toFixed(2)} q`;
-        else if (gr > 1000)
-            return `${(gr / 1000).toFixed(2)} kg`;
-        else
-            return `${gr} gr`;
+    clear() {
+        this.from = undefined;
+        this.to = undefined;
     }
-    /**
-     * Format file size
-     * @param bytes : number of bytes
-     * @returns     : the formatted string
-     */
-    static formatFileSize(bytes) {
-        if (bytes > 1024000)
-            return `${(bytes / 1024000).toFixed(1)} MB`;
-        if (bytes > 1024)
-            return `${(bytes / 1024).toFixed(1)} Kb`;
-        return `${bytes} byte`;
+}
+
+/**
+ * Zero-dependency Markdown to HTML converter.
+ *
+ * Design goals:
+ * - Single line-based pass over blocks (no repeated full-string regex passes).
+ * - Inline formatting never touches code spans / code blocks (stash & restore).
+ * - No HTML entity escaping by default in normal text: the source passes as-is.
+ *   Exception: the content of code spans / code blocks is ALWAYS escaped, so
+ *   things like List<string> render correctly (the browser displays the
+ *   original characters; entities never reach the user or the clipboard).
+ *   Opt-in full escaping via { escapeHtml: true } for untrusted input.
+ * - URL sanitization on links/images (javascript:, vbscript:, data: are dropped).
+ * - Bounded result cache for repeated renders (Angular change detection friendly).
+ *
+ * Supported syntax: headings, paragraphs, hard/soft breaks, hr, blockquotes
+ * (nested), fenced code blocks, inline code, bold/italic/strikethrough, links
+ * (with title), images, autolinked bare URLs, ordered/unordered lists (nested,
+ * task lists, ordered start offset), GFM tables with alignment, raw HTML
+ * blocks (e.g. <table>...</table>) passed through verbatim when escapeHtml
+ * is false: their newlines stay plain newlines, never converted to <br>.
+ *
+ * Known simplifications (documented, by design):
+ * - A blank line terminates a list.
+ * - Setext headings (=== / ---) are not supported, use # syntax.
+ * - Reference-style links [text][ref] are not supported.
+ */
+class MarkdownUtils {
+    // #region Cache
+    static { this.cache = new Map(); }
+    static { this.CACHE_MAX = 200; }
+    /** Clears the internal result cache. */
+    static clearCache() {
+        this.cache.clear();
     }
+    // #endregion
+    // #region Public API
     /**
-     * Compare two strings (case-insensitive, locale-aware, accent-insensitive).
-     * @param a   : string a
-     * @param b   : string b
-     * @returns   : 0 if equals, 1 if bigger, -1 if lower
+     * Convert markdown to HTML.
+     * @param markdown : the markdown source
+     * @param options  : conversion options
+     * @returns        : the HTML string ('' when input is falsy)
      */
-    static compareString(a, b) {
-        return this.collator.compare(a ?? '', b ?? '');
+    static toHtml(markdown, options) {
+        if (!markdown)
+            return '';
+        const opts = { escapeHtml: false, breaks: true, ...options };
+        const key = `${opts.escapeHtml ? 1 : 0}${opts.breaks ? 1 : 0}|${markdown}`;
+        const hit = this.cache.get(key);
+        if (hit !== undefined)
+            return hit;
+        // Normalize line endings and fix glued sentence punctuation ("dettaglio!Ecco").
+        // Only when the next char is uppercase (a new sentence), so URLs with query
+        // strings ("/page?id=1") and code identifiers are left untouched.
+        const source = markdown
+            .replace(/\r\n?/g, '\n')
+            .replace(/([a-zà-ÿ][!?])([A-ZÀ-Þ])/g, '$1 $2');
+        const html = this.parseBlocks(source.split('\n'), opts).trim();
+        if (this.cache.size >= this.CACHE_MAX) {
+            this.cache.delete(this.cache.keys().next().value); // FIFO eviction
+        }
+        this.cache.set(key, html);
+        return html;
     }
+    // #endregion
+    // #region Block parser (single pass)
+    /** Block-level HTML tags that start a raw HTML block (passthrough, no <p>/<br>). */
+    static { this.htmlBlockTags = new Set([
+        'address', 'article', 'aside', 'blockquote', 'caption', 'colgroup', 'col',
+        'dd', 'details', 'dialog', 'div', 'dl', 'dt', 'fieldset', 'figcaption',
+        'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header',
+        'hr', 'iframe', 'li', 'main', 'nav', 'ol', 'p', 'pre', 'section', 'summary',
+        'table', 'tbody', 'td', 'tfoot', 'thead', 'th', 'tr', 'ul',
+    ]); }
+    /** Void/self-contained tags: a single tag, no closing tag expected. */
+    static { this.htmlVoidTags = new Set(['hr', 'col', 'img', 'input']); }
     /**
-     * Capitalize a string
-     * @param s   : the string to capitalize
-     * @returns   : the capitalized string
+     * Precompiled: first block-level tag occurrence anywhere in a line.
+     * Anchored on the '<' literal, so scanning is cheap; the lookahead
+     * prevents partial matches ('<td' must not match inside '<tdx').
      */
-    static capitalize(s) {
-        if (!s)
-            return undefined;
-        let b = "";
-        let cap = true;
-        for (const char of s) {
-            if (char === " ") {
-                b += char;
-                cap = true;
-            }
-            else if (cap) {
-                b += char.toUpperCase();
-                cap = false;
-            }
-            else {
-                b += char.toLowerCase();
+    static { this.htmlBlockScanRe = new RegExp(`<(\\/?)(${[...MarkdownUtils.htmlBlockTags].join('|')})(?=[\\s/>])`, 'gi'); }
+    /** Result of scanning a line for the start of a raw HTML block. */
+    static findHtmlBlockStart(line) {
+        // HTML comment candidate (skipping occurrences inside inline code spans)
+        let comment = line.indexOf('<!--');
+        while (comment !== -1 && this.insideCodeSpan(line, comment)) {
+            comment = line.indexOf('<!--', comment + 4);
+        }
+        // Block tag candidate (same code-span guard)
+        const re = this.htmlBlockScanRe;
+        re.lastIndex = 0;
+        let m;
+        let tagHit;
+        while ((m = re.exec(line)) !== null) {
+            if (!this.insideCodeSpan(line, m.index)) {
+                tagHit = { index: m.index, tag: m[2].toLowerCase(), isClose: m[1] === '/' };
+                break;
             }
         }
-        return b;
+        if (comment !== -1 && (!tagHit || comment < tagHit.index)) {
+            return { index: comment, tag: '', isClose: false, isComment: true };
+        }
+        return tagHit ? { ...tagHit, isComment: false } : undefined;
     }
-    /**
-     * Truncate a string at the last word boundary before `max`.
-     * @param s     : the string to truncate
-     * @param max   : the max number of chars
-     * @returns     : the truncated string
-     */
-    static truncate(s, max = 500) {
-        if (!s)
-            return undefined;
-        if (s.length < max)
-            return s;
-        const i = s.lastIndexOf(' ', max - 1);
-        return i > 0 ? s.slice(0, i) : s;
+    /** True when `index` falls inside an inline code span (odd backtick count before it). */
+    static insideCodeSpan(line, index) {
+        let count = 0;
+        for (let i = 0; i < index; i++) {
+            if (line.charCodeAt(i) === 96 /* ` */)
+                count++;
+        }
+        return (count & 1) === 1;
     }
     /**
-     * Join a list of strings
-     * @param items     : the list of strings
-     * @param sep       : the separator string
-     * @param max       : the maximum resulting string
-     * @returns         : the joined string
+     * indexOf-based depth scanner (no regex, no allocations): walks `text`
+     * adjusting `depth` for <tag ...> / </tag> occurrences of the SAME tag.
+     * Self-closing <tag ... /> forms do not alter depth.
+     * @returns [newDepth, endIndex] where endIndex is the position right after
+     *          the '>' that balanced the element, or -1 when still open.
      */
-    static join(items, sep = " ", max = 350) {
-        if (!items || items.length === 0)
-            return undefined;
-        if (items.length > 1) {
-            let l = 0;
-            let s = "";
-            while (s.length < max && items.length > l) {
-                if (l > 0) {
-                    s += sep;
+    static scanHtmlDepth(text, tag, depth) {
+        const lower = text.toLowerCase();
+        const open = '<' + tag;
+        const close = '</' + tag;
+        let i = 0;
+        while ((i = lower.indexOf('<', i)) !== -1) {
+            if (lower.startsWith(close, i) && this.isTagBoundary(lower, i + close.length)) {
+                depth--;
+                const gt = lower.indexOf('>', i);
+                const end = gt === -1 ? lower.length : gt + 1;
+                if (depth <= 0)
+                    return [0, end];
+                i = end;
+            }
+            else if (lower.startsWith(open, i) && this.isTagBoundary(lower, i + open.length)) {
+                const gt = lower.indexOf('>', i);
+                const selfClosing = gt !== -1 && lower.charCodeAt(gt - 1) === 47 /* / */;
+                if (selfClosing) {
+                    if (depth === 0)
+                        return [0, gt + 1]; // standalone self-closed element
                 }
-                s += items[l++];
+                else {
+                    depth++;
+                }
+                i = gt === -1 ? lower.length : gt + 1;
             }
-            if (items.length > l) {
-                s += "...";
+            else {
+                i++;
             }
-            return s;
         }
-        return items[0];
-    }
-    /**
-     * Normalize a string by converting it to lowercase and removing extra spaces, with special handling for acronyms and camelCase.
-     * @param s  : the string to normalize
-     * @returns  : The normalized string, or `undefined` if the input is falsy.
-     */
-    static normalizeDisplay(s) {
-        if (!s)
-            return s;
-        return s
-            .split(' ')
-            .map((word, wordIndex) => {
-            if (!word)
-                return word;
-            // If the word is all uppercase and contains at least one letter, we assume it's an acronym and leave it as is
-            if (word === word.toUpperCase() && /[A-Z]/.test(word)) {
-                return word;
-            }
-            // Otherwise, convert to lowercase letter by letter
-            const chars = word.split('');
-            return chars
-                .map((char, charIndex) => {
-                if (charIndex === 0 && wordIndex === 0) {
-                    // First letter of the first word:
-                    // remains uppercase only if the first 2 letters are both uppercase
-                    const secondChar = chars[1] ?? '';
-                    const keepUppercase = char === char.toUpperCase() &&
-                        secondChar === secondChar.toUpperCase() &&
-                        /[A-Z]/.test(char) &&
-                        /[A-Z]/.test(secondChar);
-                    return keepUppercase ? char : char.toLowerCase();
-                }
-                return char.toLowerCase();
-            })
-                .join('');
-        })
-            .join(' ');
+        return [depth, -1];
     }
-    /**
-     * Wraps bare URLs in the given string with `<a>` anchor tags.
-     * @param s - The plain-text or HTML string to process.
-     * @returns The string with URLs replaced by clickable links, or `''` when `s` is falsy.
-     */
-    static replaceAsHtml(s) {
-        if (!s)
-            return '';
-        return s.replace(/https?:\/\/[^\s<]+/gi, v => `<a href="${v}" target="_blank" rel="noopener">${v}</a>`);
+    /** A tag token must be followed by whitespace, '/', '>' or end of line. */
+    static isTagBoundary(s, idx) {
+        if (idx >= s.length)
+            return true; // tag opening continues on the next line
+        const c = s.charCodeAt(idx);
+        return c === 62 /* > */ || c === 47 /* / */ || c === 32 /* space */ || c === 9 /* tab */;
     }
     /**
-     * Convert markdown to html
-     * @param markdown : the markdown data
-     * @param escapeHtml : true to escape HTML. Default is false
-     * @returns the html
+     * Re-injects the remainder of a partially consumed line so the main loop
+     * processes it as markdown. Returns the index the loop should resume from.
      */
-    static markdownToHtml(markdown, escapeHtml = false) {
-        return MarkdownUtils.toHtml(markdown, { escapeHtml: escapeHtml });
+    static pushBack(lines, i, remainder) {
+        if (remainder.trim()) {
+            lines[i] = remainder;
+            return i - 1; // the loop's i++ re-processes the remainder
+        }
+        return i;
     }
     /**
-     * Compare two names
-     * @param a   : name a
-     * @param b   : name b
-     * @returns   : true if a equals b
+     * Emits a raw HTML block starting at `hit.index` of lines[i], consuming
+     * following lines until the element is balanced. Text after the block on
+     * the closing line is pushed back for markdown processing.
+     * @returns the index of the last consumed line
      */
-    static compareNames(a, b) {
-        if (a)
-            a = a.trim();
-        if (b)
-            b = b.trim();
-        if (a && b && a.length !== b.length)
-            return false;
-        if (this.compareString(a, b) === 0)
-            return true;
-        const p1 = (a ?? '').split(' ');
-        const p2 = (b ?? '').split(' ');
-        if (p1.length !== p2.length)
-            return false;
-        let matches = p1.length;
-        for (const s1 of p1) {
-            for (const s2 of p2) {
-                if (this.compareString(s1, s2) === 0) {
-                    matches--;
-                    break;
+    static emitHtmlBlock(lines, i, hit, out) {
+        const line = lines[i];
+        // HTML comment: raw until '-->'
+        if (hit.isComment) {
+            let end = line.indexOf('-->', hit.index);
+            if (end !== -1) {
+                out.push(line.slice(hit.index, end + 3));
+                return this.pushBack(lines, i, line.slice(end + 3));
+            }
+            out.push(line.slice(hit.index));
+            while (++i < lines.length) {
+                end = lines[i].indexOf('-->');
+                if (end !== -1) {
+                    out.push(lines[i].slice(0, end + 3));
+                    return this.pushBack(lines, i, lines[i].slice(end + 3));
                 }
+                out.push(lines[i]);
             }
+            return lines.length - 1; // unterminated: consumed to EOF
         }
-        return matches === 0;
-    }
-    /**
-     * Cipher a text
-     * @param text    : the text
-     * @param key     : the key
-     * @param reverse : true to decode, false to encode
-     * @returns       :the ciphered text
-     */
-    static cipher(text, key, reverse = false) {
-        if (!text || !key)
-            return undefined;
-        // Surrogate pair limit
-        const bound = 0x10000;
-        const keyLen = key.length;
-        let result = '';
-        for (let i = 0; i < text.length; i++) {
-            let rotation = key.charCodeAt(i % keyLen);
-            if (reverse)
-                rotation = -rotation;
-            result += String.fromCharCode((text.charCodeAt(i) + rotation + bound) % bound);
+        // Stray closing tag or void tag: emit just the tag, resume after '>'
+        if (hit.isClose || this.htmlVoidTags.has(hit.tag)) {
+            const gt = line.indexOf('>', hit.index);
+            const end = gt === -1 ? line.length : gt + 1;
+            out.push(line.slice(hit.index, end));
+            return this.pushBack(lines, i, line.slice(end));
         }
-        return result;
+        // Opening block tag: raw until the element is balanced (depth === 0)
+        let [depth, split] = this.scanHtmlDepth(line.slice(hit.index), hit.tag, 0);
+        if (split !== -1) {
+            out.push(line.slice(hit.index, hit.index + split));
+            return this.pushBack(lines, i, line.slice(hit.index + split));
+        }
+        out.push(line.slice(hit.index));
+        while (depth > 0 && ++i < lines.length) {
+            [depth, split] = this.scanHtmlDepth(lines[i], hit.tag, depth);
+            if (split !== -1) {
+                out.push(lines[i].slice(0, split));
+                return this.pushBack(lines, i, lines[i].slice(split));
+            }
+            out.push(lines[i]);
+        }
+        return Math.min(i, lines.length - 1);
     }
-    /**
-     * Clone an object (deep copy).
-     * Uses native structuredClone: handles Date, Map, Set, typed arrays and circular references.
-     * @param obj : the object to clone
-     * @returns   : a new object
-     */
-    static clone(obj) {
-        if (!obj)
-            return {};
-        return structuredClone(obj);
-    }
-    /**
-     * Creates a deep clone of an object.
-     * @param obj  - The source object to clone.
-     * @param dest - Optional pre-allocated destination object to merge the clone into.
-     * @returns A deep copy of `obj`.
-     */
-    static deepClone(obj, dest) {
-        const cloned = structuredClone(obj);
-        if (dest) {
-            Object.assign(dest, cloned);
-            return dest;
-        }
-        return cloned;
-    }
-    /**
-     * Returns `true` when `value` is a syntactically valid UUID string.
-     * @param value - The string to validate.
-     */
-    static parseUUID(value) {
-        const regex = /^({|()?[0-9a-fA-F]{8}-([0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}(}|))?$/;
-        return !!value && value.length > 0 && regex.test(value);
-    }
-    /**
-     * Returns `true` when `value` is a valid, non-empty (non-zero) UUID.
-     * @param value - The string to validate.
-     */
-    static parseUUIDNotEmpty(value) {
-        const regex = /^({|()?0{8}-(0{4}-){3}0{12}(}|))?$/;
-        return this.parseUUID(value) && !regex.test(value ?? '');
-    }
-    /**
-     * Return an empty UUID
-     * @returns : the empty UUID
-     */
-    static emptyUUID() { return "00000000-0000-0000-0000-000000000000"; }
-    ;
-    /**
-     * Create a new UUID
-     * @returns : the string UUID
-     */
-    static generateUUID() {
-        if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
-            return crypto.randomUUID();
+    static parseBlocks(lines, opts) {
+        const out = [];
+        let paragraph = [];
+        const flush = () => {
+            if (paragraph.length > 0) {
+                const sep = opts.breaks ? '<br>' : ' ';
+                out.push(`<p>${paragraph.map(l => this.inline(l, opts)).join(sep)}</p>`);
+                paragraph = [];
+            }
+        };
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const trimmed = line.trim();
+            // --- Fenced code block -------------------------------------------------
+            const fence = trimmed.match(/^```([\w+-]+)?\s*$/);
+            if (fence) {
+                flush();
+                const lang = fence[1] ? ` class="language-${fence[1]}"` : '';
+                const code = [];
+                i++;
+                while (i < lines.length && !/^```\s*$/.test(lines[i].trim())) {
+                    code.push(lines[i]);
+                    i++;
+                }
+                out.push(`<pre><code${lang}>${this.escape(code.join('\n'))}</code></pre>`);
+                continue;
+            }
+            // --- Blank line --------------------------------------------------------
+            if (!trimmed) {
+                flush();
+                continue;
+            }
+            // --- Raw HTML block passthrough (only with escaping disabled) ------------
+            // A block-level HTML element found ANYWHERE in the line starts a raw
+            // block: text before it joins the current paragraph, the element is
+            // emitted as-is (plain newlines, no <p>, no <br>) until balanced, and
+            // any text after the closing tag resumes markdown processing.
+            if (!opts.escapeHtml && line.includes('<')) {
+                const hit = this.findHtmlBlockStart(line);
+                if (hit) {
+                    const before = line.slice(0, hit.index).trim();
+                    if (before)
+                        paragraph.push(before);
+                    flush();
+                    i = this.emitHtmlBlock(lines, i, hit, out);
+                    continue;
+                }
+            }
+            // --- ATX heading -------------------------------------------------------
+            const heading = trimmed.match(/^(#{1,6})\s+(.+?)\s*#*\s*$/);
+            if (heading) {
+                flush();
+                const level = heading[1].length;
+                out.push(`<h${level}>${this.inline(heading[2], opts)}</h${level}>`);
+                continue;
+            }
+            // --- Horizontal rule ---------------------------------------------------
+            if (/^(?:-{3,}|\*{3,}|_{3,})$/.test(trimmed)) {
+                flush();
+                out.push('<hr>');
+                continue;
+            }
+            // --- Blockquote (consecutive lines, one level stripped, recursive) ------
+            if (/^>\s?/.test(trimmed)) {
+                flush();
+                const quoted = [];
+                while (i < lines.length && /^>\s?/.test(lines[i].trim())) {
+                    quoted.push(lines[i].trim().replace(/^>\s?/, ''));
+                    i++;
+                }
+                i--;
+                out.push(`<blockquote>${this.parseBlocks(quoted, opts)}</blockquote>`);
+                continue;
+            }
+            // --- Table (header row + separator row) ---------------------------------
+            if (trimmed.includes('|') &&
+                i + 1 < lines.length &&
+                lines[i + 1].includes('-') &&
+                /^\|?[\s:\-|]+\|?$/.test(lines[i + 1].trim())) {
+                flush();
+                const aligns = this.tableAligns(lines[i + 1].trim());
+                const head = this.tableRow(trimmed, 'th', aligns, opts);
+                const body = [];
+                i += 2;
+                while (i < lines.length && lines[i].trim().includes('|')) {
+                    body.push(this.tableRow(lines[i].trim(), 'td', aligns, opts));
+                    i++;
+                }
+                i--;
+                out.push(`<table>\n<thead>\n${head}\n</thead>` +
+                    (body.length > 0 ? `\n<tbody>\n${body.join('\n')}\n</tbody>` : '') +
+                    `\n</table>`);
+                continue;
+            }
+            // --- List ---------------------------------------------------------------
+            if (MarkdownUtils.listItemRe.test(line)) {
+                flush();
+                const [html, last] = this.parseList(lines, i, opts);
+                out.push(html);
+                i = last;
+                continue;
+            }
+            // --- Plain text: accumulate into current paragraph ----------------------
+            paragraph.push(trimmed);
         }
-        // Fallback (non-secure contexts)
-        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-            const r = (Math.random() * 16) | 0;
-            const v = c === 'x' ? r : (r & 0x3) | 0x8;
-            return v.toString(16);
-        });
-    }
-    /**
-     * Reconstruct a standard UUID (with dashes) from a 32-char hex string without dashes.
-     * @param value : 32-character hex string
-     * @returns     : the formatted UUID or the original string if it doesn't match the expected format
-     */
-    static inflateUUID(value) {
-        const s = value.trim();
-        if (s.length !== 32)
-            return s;
-        return `${s.slice(0, 8)}-${s.slice(8, 12)}-${s.slice(12, 16)}-${s.slice(16, 20)}-${s.slice(20)}`;
-    }
-    /** Precompiled validation patterns. */
-    static { this.emailRegex = /^(?:[a-z0-9+!#$%&'*+\/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+\/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])$/i; }
-    static { this.urlRegex = /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w .-]*)\/?$/i; }
-    /**
-     * Parse a text and return true if it is a valid email (or empty)
-     * @param value : email
-     * @returns     : true if the email is valid or empty
-     */
-    static parseEmail(value) {
-        if (!value)
-            return true;
-        return this.emailRegex.test(value.trim().toLowerCase());
-    }
-    /**
-     * Parse a text containing one or more email addresses separated by `;` or `,`
-     * and return true if all of them are valid (or the text is empty).
-     * Empty items caused by double or trailing separators are ignored.
-     * @param value : the email list to parse (e.g. "a@b.it; c@d.it")
-     * @returns     : true if all emails are valid or the value is empty
-     */
-    static parseEmails(value) {
-        if (!value || value.trim().length === 0)
-            return true;
-        const items = value
-            .split(/[;,]/)
-            .map(e => e.trim().toLowerCase())
-            .filter(e => e.length > 0);
-        if (items.length === 0)
-            return false; // only separators, no addresses
-        return items.every(e => this.emailRegex.test(e));
-    }
-    /**
-     * Parse a text and return true if it is a valid url (or empty)
-     * @param value : the url to parse
-     * @returns     : true if the url is valid or empty
-     */
-    static parseUrl(value) {
-        if (!value)
-            return true;
-        return this.urlRegex.test(value.trim().toLowerCase());
+        flush();
+        return out.join('\n');
     }
+    // #endregion
+    // #region Lists
+    /** Matches "- item", "* item", "+ item", "1. item", "1) item" with leading indent. */
+    static { this.listItemRe = /^(\s*)([-*+]|\d+[.)])\s+(.*)$/; }
     /**
-     * Get date parts from a string value
-     * @param value   : the string to parse
-     * @returns       : an array of numbers with year, month, day
+     * Gathers the contiguous list block starting at `start`, builds it (with
+     * nesting) and returns [html, indexOfLastConsumedLine].
      */
-    static getDateParts(value) {
-        if (!value)
-            return undefined;
-        let parts = [];
-        if (value.indexOf("-") !== -1) {
-            const p = value.split("-");
-            if (p.length !== 3)
-                return undefined;
-            parts = [parseInt(p[0]), parseInt(p[1]) - 1, parseInt(p[2])];
-        }
-        else if (value.indexOf("/") !== -1) {
-            const p = value.split("/");
-            if (p.length !== 3)
-                return undefined;
-            parts = [parseInt(p[2]), parseInt(p[1]) - 1, parseInt(p[0])];
+    static parseList(lines, start, opts) {
+        const block = [];
+        let i = start;
+        while (i < lines.length) {
+            const l = lines[i];
+            if (!l.trim())
+                break; // blank line ends the list
+            if (this.listItemRe.test(l) || /^\s{2,}\S/.test(l)) {
+                block.push(l);
+                i++;
+            }
+            else
+                break;
         }
-        return parts;
-    }
-    /**
-     * Parse a date
-     * @param value   : the value to check
-     * @param locale  : the locale to use
-     * @returns       : a valid Date object or null
-     */
-    static parseDate(value, locale = it) {
-        // No value at all
-        if (!value)
-            return undefined;
-        // A Date value
-        if (value instanceof Date && value.getTime())
-            return value;
-        // Parse known formats using date-fns
-        let d = parseISO(value);
-        if (d && d.getTime() && d.getFullYear() > 1750)
-            return d;
-        d = parse(value, 'dd/MM/yyyy', new Date(), { locale: locale });
-        if (d && d.getTime() && d.getFullYear() > 1750)
-            return d;
-        d = parse(value, 'yyyy-MM-dd', new Date(), { locale: locale });
-        if (d && d.getTime() && d.getFullYear() > 1750)
-            return d;
-        // Parse values manually
-        const parts = this.getDateParts(value);
-        if (!parts)
-            return undefined;
-        if (parts[0] < 100)
-            parts[0] += 2000;
-        if (isNaN(parts[0]) || parts[0] < 0 || parts[0] < 1750)
-            return undefined;
-        if (isNaN(parts[1]) || parts[1] < 0)
-            return undefined;
-        if (isNaN(parts[2]) || parts[2] < 0)
-            return undefined;
-        if (parts[1] > 11)
-            return undefined;
-        if (parts[1] === 1 && parts[2] > 29)
-            return undefined;
-        else if (parts[1] !== 1 && parts[2] > 31)
-            return undefined;
-        return new TZDate(parts[0], parts[1], parts[2], 12);
+        return [this.buildList(block, opts), i - 1];
     }
-    /**
-     * Format a date
-     * @param value     : the date or string to format
-     * @param fmt       : the DateFormat to use or the string pattern
-     * @param locale    : the locale to use (default is IT)
-     * @returns         : the formatted string
-     */
-    static formatDate(value, fmt = DateFormat.Short, locale = it) {
-        // No value at all
-        if (!value)
-            return '';
-        // A string
-        if (typeof value === 'string' || value instanceof String)
-            value = this.parseDate(value);
-        // Not a date
-        if (!(value instanceof Date && value.getTime()))
-            return '';
-        // Format
-        switch (fmt) {
-            case DateFormat.Short: return format(value, "dd/MM/yyyy", { locale: locale });
-            case DateFormat.Long: return format(value, "d MMMM yyyy", { locale: locale });
-            case DateFormat.LongWithShortMonth: return format(value, "d MMM yyyy", { locale: locale });
-            case DateFormat.LongWithWeekDay: return format(value, "EEEE, d MMMM yyyy", { locale: locale });
-            case DateFormat.LongWithShortWeekDay: return format(value, "EEE, d MMMM yyyy", { locale: locale });
-            case DateFormat.MonthAndYear: return format(value, "MMM yyyy", { locale: locale });
-            case DateFormat.LongMonthAndYear: return format(value, "MMMM yyyy", { locale: locale });
-            case DateFormat.WeekDay: return format(value, "EEE, d", { locale: locale });
-            case DateFormat.LongWeekDay: return format(value, "EEEE, d", { locale: locale });
-            case DateFormat.DayAndMonth: return format(value, "d MMMM", { locale: locale });
-            case DateFormat.ShortUS: return format(value, "MM/dd/yyyy", { locale: locale });
-            case DateFormat.ShortISO8601: return format(value, "yyyy-MM-dd", { locale: locale });
-            default:
-                return format(value, fmt, { locale: locale });
+    static buildList(block, opts) {
+        const first = block[0].match(this.listItemRe);
+        const baseIndent = first[1].length;
+        const ordered = /^\d/.test(first[2]);
+        const startNum = ordered ? parseInt(first[2], 10) : 1;
+        const items = [];
+        for (const l of block) {
+            const m = l.match(this.listItemRe);
+            if (m && m[1].length <= baseIndent) {
+                items.push({ text: m[3], childLines: [] });
+            }
+            else if (items.length > 0) {
+                // Continuation or nested content: strip one nesting level of indent
+                items[items.length - 1].childLines.push(l.length > baseIndent + 2 ? l.slice(baseIndent + 2) : l.trim());
+            }
         }
-    }
-    /**
-     * Return an italian local date
-     * @param value  : the date
-     * @returns     : the new date
-     */
-    static toLocalDate(value) {
-        // No value at all
-        if (!value)
-            return undefined;
-        // A string
-        if (typeof value === 'string' || value instanceof String)
-            value = this.parseDate(value);
-        // Not a date
-        if (!(value instanceof Date && value.getTime()))
-            return undefined;
-        // Update date
-        return new TZDate(value, "Europe/Rome");
-    }
-    /**
-     * Update a DateInterval object according to a string
-     * @param value       : string value
-     * @param interval    : DateInterval value to update
-     * @param end         : true if must be updated the first or the end value
-     * @param copy        : copy the same value (works only if not end element)
-     */
-    static changeDateInterval(value, interval, end = false, copy = false) {
-        if (value) {
-            let year = -1;
-            if (value.length === 4 && (year = parseInt(value)) > 1750) {
-                if (!end) {
-                    interval.from = new TZDate(new Date(year, 0, 1), 'Europe/Rome');
-                    interval.to = new TZDate(new Date(year, 11, 31), 'Europe/Rome');
-                }
-                else
-                    interval.to = new Date(year, 11, 31);
+        const lis = items.map(item => {
+            let inner;
+            // GFM task list: - [ ] / - [x]
+            const task = item.text.match(/^\[([ xX])\]\s+(.*)$/);
+            if (task) {
+                const checked = task[1] !== ' ' ? ' checked' : '';
+                inner = `<input type="checkbox" disabled${checked}> ${this.inline(task[2], opts)}`;
             }
             else {
-                let parts = this.getDateParts(value);
-                if (!parts || isNaN(parts[0]) || parts[0] < 0 || parts[0] < 1750)
-                    return;
-                const d = new TZDate(new Date(parts[0], parts[1], parts[2]), 'Europe/Rome');
-                if (end)
-                    interval.to = d;
-                else if (copy) {
-                    interval.from = d;
-                    interval.to = d;
-                }
-                else
-                    interval.from = d;
+                inner = this.inline(item.text, opts);
             }
-        }
-    }
-    /**
-     * Formats a number using `Intl.NumberFormat`.
-     * @param value    - The number to format.
-     * @param decimals - Maximum decimal places (default: `2`).
-     * @param locale   - BCP 47 locale tag (default: `'it-IT'`).
-     * @returns The formatted number string.
-     */
-    static formatNumber(value, decimals = 2, locale = 'it-IT') {
-        return Intl.NumberFormat(locale, { style: 'decimal', minimumFractionDigits: 0, maximumFractionDigits: decimals }).format(value);
+            if (item.childLines.length > 0) {
+                inner += '\n' + this.parseBlocks(item.childLines, opts);
+            }
+            return `<li>${inner}</li>`;
+        });
+        const tag = ordered ? 'ol' : 'ul';
+        const startAttr = ordered && startNum > 1 ? ` start="${startNum}"` : '';
+        return `<${tag}${startAttr}>\n${lis.join('\n')}\n</${tag}>`;
     }
-    /**
-     * Formats a number as a currency string using `Intl.NumberFormat`.
-     * @param value    - The number to format.
-     * @param currency - ISO 4217 currency code (default: `'EUR'`).
-     * @param decimals - Maximum decimal places (default: `2`).
-     * @param locale   - BCP 47 locale tag (default: `'it-IT'`).
-     * @returns The formatted currency string.
-     */
-    static formatCurrency(value, currency = 'EUR', decimals = 2, locale = 'it-IT') {
-        return Intl.NumberFormat(locale, { style: 'currency', currency, minimumFractionDigits: 0, maximumFractionDigits: decimals }).format(value);
+    // #endregion
+    // #region Tables
+    static tableAligns(separator) {
+        return separator
+            .replace(/^\||\|$/g, '')
+            .split('|')
+            .map(cell => {
+            const t = cell.trim();
+            if (t.startsWith(':') && t.endsWith(':'))
+                return 'center';
+            if (t.endsWith(':'))
+                return 'right';
+            if (t.startsWith(':'))
+                return 'left';
+            return undefined;
+        });
     }
-    /**
-     * Percent-encodes a string for safe inclusion in a URL.
-     * @param value - The string to encode.
-     * @returns The encoded string, or `undefined` when `value` is empty.
-     */
-    static urlEncode(value) {
-        return value.length > 0
-            ? encodeURIComponent(value)
-            : undefined;
+    static tableRow(row, tag, aligns, opts) {
+        const cells = row.replace(/^\||\|$/g, '').split('|').map(c => c.trim());
+        const cellsHtml = cells
+            .map((cell, j) => {
+            const align = aligns[j] ? ` align="${aligns[j]}"` : '';
+            return `<${tag}${align}>${this.inline(cell, opts)}</${tag}>`;
+        })
+            .join('');
+        return `<tr>${cellsHtml}</tr>`;
     }
+    // #endregion
+    // #region Inline formatting
     /**
-     * Decodes a percent-encoded URL string, treating `+` as a space.
-     * @param value - The encoded string to decode.
-     * @returns The decoded string, or `undefined` when `value` is empty or absent.
+     * Applies inline markdown to a single text segment.
+     * Generated HTML (code, links, images, autolinks) is stashed behind \u0000
+     * placeholders so later regex passes can never corrupt it.
      */
-    static urlDecode(value) {
-        return value && value.length > 0
-            ? decodeURIComponent(value.replace(/\+/g, '%20'))
-            : undefined;
+    static inline(text, opts) {
+        const store = [];
+        const stash = (html) => `\u0000${store.push(html) - 1}\u0000`;
+        // 1. Inline code: stash first so later passes can't touch it.
+        //    Content is ALWAYS escaped so <, >, & inside code survive in the DOM
+        //    (the browser renders entities back to the original characters).
+        let s = text.replace(/`([^`]+)`/g, (_m, code) => stash(`<code>${this.escape(code)}</code>`));
+        // 2. Escape raw HTML as entities (opt-in only)
+        if (opts.escapeHtml)
+            s = this.escape(s);
+        // 3. Images: ![alt](url "title")
+        s = s.replace(/!\[([^\]]*)\]\(\s*([^)\s]+)(?:\s+(?:"|&quot;)(.+?)(?:"|&quot;))?\s*\)/g, (_m, alt, src, title) => {
+            const url = this.safeUrl(src);
+            if (!url)
+                return alt;
+            const t = title ? ` title="${this.escapeAttr(title)}"` : '';
+            return stash(`<img src="${url}" alt="${this.escapeAttr(alt)}"${t} loading="lazy">`);
+        });
+        // 4. Links: [text](url "title")
+        s = s.replace(/\[([^\]]+)\]\(\s*([^)\s]+)(?:\s+(?:"|&quot;)(.+?)(?:"|&quot;))?\s*\)/g, (_m, txt, href, title) => {
+            const url = this.safeUrl(href);
+            if (!url)
+                return txt;
+            const t = title ? ` title="${this.escapeAttr(title)}"` : '';
+            return stash(`<a href="${url}"${t} target="_blank" rel="noopener noreferrer">${txt}</a>`);
+        });
+        // 5. Autolink remaining bare URLs (markdown links are already stashed)
+        s = s.replace(/https?:\/\/[^\s<>"']+/g, url => stash(`<a href="${url}" target="_blank" rel="noopener noreferrer">${url}</a>`));
+        // 6. Bold / italic / strikethrough.
+        //    Delimiters must hug the text; underscore emphasis only at word
+        //    boundaries so identifiers like snake_case are left untouched.
+        s = s.replace(/\*\*\*(?=\S)([\s\S]*?\S)\*\*\*/g, '<strong><em>$1</em></strong>');
+        s = s.replace(/(?<![\w*])___(?=\S)([\s\S]*?\S)___(?![\w*])/g, '<strong><em>$1</em></strong>');
+        s = s.replace(/\*\*(?=\S)([\s\S]*?\S)\*\*/g, '<strong>$1</strong>');
+        s = s.replace(/(?<![\w*])__(?=\S)([\s\S]*?\S)__(?![\w*])/g, '<strong>$1</strong>');
+        s = s.replace(/\*(?=\S)([^*\n]*?\S)\*/g, '<em>$1</em>');
+        s = s.replace(/(?<![\w_])_(?=\S)([^_\n]*?\S)_(?![\w_])/g, '<em>$1</em>');
+        s = s.replace(/~~(?=\S)([\s\S]*?\S)~~/g, '<del>$1</del>');
+        // 7. Restore stashed HTML
+        return s.replace(/\u0000(\d+)\u0000/g, (_m, idx) => store[Number(idx)] ?? '');
+    }
+    // #endregion
+    // #region Security helpers
+    /** Escapes quotes for safe interpolation inside a double-quoted HTML attribute. */
+    static escapeAttr(s) {
+        return s.replace(/&(?!(?:amp|lt|gt|quot|#\d+);)/g, '&amp;').replace(/"/g, '&quot;');
+    }
+    /** Escapes &, <, > and " for safe HTML interpolation. */
+    static escape(s) {
+        return s
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;');
     }
     /**
-     * Reads a query string parameter value from the current page URL.
-     * @param name - The parameter name to look up.
-     * @returns The decoded parameter value, or `undefined` when absent or running server-side.
+     * Returns a sanitized URL or undefined when the scheme is dangerous.
+     * Blocks javascript:, vbscript: and data: (also when obfuscated with
+     * whitespace/control characters, e.g. "java\tscript:").
      */
-    static getQueryStringValueByName(name) {
-        if (!this.isBrowser())
+    static safeUrl(url) {
+        const compact = url.replace(/[\s\u0000-\u001f]/g, '');
+        if (/^(javascript|vbscript|data):/i.test(compact))
             return undefined;
-        const v = new URLSearchParams(window.location.search).get(name);
-        return v && v !== 'null' ? v : undefined;
+        return url.replace(/"/g, '%22');
     }
+    // #endregion
+    // #region Clipboard
     /**
-     * Generate a password
-     * @returns : the password string
+     * Copies markdown content to the clipboard in two flavors:
+     * - text/html  : the rendered HTML (rich paste into Word, Outlook, Gmail...)
+     * - text/plain : the original markdown source (paste into editors, IDEs...)
+     * @param markdown : the markdown source
+     * @param options  : conversion options for the HTML flavor
+     * @returns        : true on success
      */
-    static generatePassword() {
-        const random = "$" + Math.random().toString(36).slice(-11);
-        let password = "";
-        let hasUpperCase = false;
-        for (const rnd of random) {
-            if (!hasUpperCase && "abcdefghjilmnopqrstuvywxz".includes(rnd)) {
-                password += rnd.toUpperCase();
-                hasUpperCase = true;
+    static async copyToClipboard(markdown, options) {
+        if (!markdown || typeof navigator === 'undefined' || !navigator.clipboard)
+            return false;
+        try {
+            if (typeof ClipboardItem !== 'undefined') {
+                const html = this.toHtml(markdown, options);
+                await navigator.clipboard.write([
+                    new ClipboardItem({
+                        'text/html': new Blob([html], { type: 'text/html' }),
+                        'text/plain': new Blob([markdown], { type: 'text/plain' }),
+                    }),
+                ]);
             }
             else {
-                password += rnd;
+                // Older engines: plain text only
+                await navigator.clipboard.writeText(markdown);
             }
+            return true;
+        }
+        catch {
+            // Clipboard API requires a secure context and user activation
+            return false;
         }
-        if (!hasUpperCase)
-            password = password.substring(0, 11) + "M";
-        return password;
     }
     /**
-     * Calculate password strength
-     * @param password: the password to evaluate
-     * @returns the password strength info
+     * Copies plain text (e.g. the content of a single code block) to the clipboard.
+     * @param text : the text to copy
+     * @returns    : true on success
      */
-    static calculatePasswordStrength(password) {
-        if (password && password.length > 0) {
-            let score = 0;
-            const suggestions = [];
-            // Length
-            if (password.length >= 10)
-                score++;
-            else
-                suggestions.push('Usa almeno 10 caratteri.');
-            if (password.length >= 12)
-                score++;
-            else if (password.length >= 10)
-                suggestions.push('Considera di usare più di 12 caratteri.');
-            // Lowercase letters
-            if (/[a-z]/.test(password))
-                score++;
-            else
-                suggestions.push('Aggiungi lettere minuscole.');
-            // Uppercase letters
-            if (/[A-Z]/.test(password))
-                score++;
-            else
-                suggestions.push('Aggiungi lettere maiuscole.');
-            // Numbers
-            if (/\d/.test(password))
-                score++;
-            else
-                suggestions.push('Aggiungi numeri.');
-            // Special characters
-            if (/[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]/.test(password))
-                score++;
-            else
-                suggestions.push('Aggiungi caratteri speciali (!@#$%^&*).');
-            // Common patterns
-            if (/(.)\1{2,}/.test(password)) {
-                score = Math.max(0, score - 1);
-                suggestions.push('Evita di ripetere lo stesso carattere.');
-            }
-            if (/123|abc|qwe/i.test(password)) {
-                score = Math.max(0, score - 1);
-                suggestions.push('Evita sequenze comuni (123, abc, qwe).');
-            }
-            // Label and color
-            let label;
-            let color;
-            let isValid;
-            if (score <= 2) {
-                label = 'Molto debole';
-                color = '#f44336';
-                isValid = false;
-            }
-            else if (score <= 3) {
-                label = 'Debole';
-                color = '#ff9800';
-                isValid = false;
-            }
-            else if (score <= 4) {
-                label = 'Media';
-                color = '#ffc107';
-                isValid = true;
-            }
-            else if (score <= 5) {
-                label = 'Forte';
-                color = '#8bc34a';
-                isValid = true;
-            }
-            else {
-                label = 'Molto forte';
-                color = '#4caf50';
-                isValid = true;
-            }
-            return { score, label, color, suggestions, isValid };
+    static async copyText(text) {
+        if (!text || typeof navigator === 'undefined' || !navigator.clipboard)
+            return false;
+        try {
+            await navigator.clipboard.writeText(text);
+            return true;
+        }
+        catch {
+            return false;
         }
-        else
-            return {
-                score: 0,
-                isValid: false,
-                suggestions: []
-            };
     }
     /**
-     * Check if current browser supports touch
-     * @returns : true if the display is touchable
+     * Extracts the visible plain text from a rendered element
+     * (what the user sees, entities already decoded by the browser).
+     * @param element : the element hosting the rendered markdown
+     * @returns       : the plain text
      */
-    static isTouchable() {
-        return (this.isBrowser() && ("ontouchstart" in window ||
-            navigator.maxTouchPoints > 0));
+    static elementToText(element) {
+        return element.innerText ?? element.textContent ?? '';
     }
+}
+
+var DateFormat;
+(function (DateFormat) {
+    DateFormat[DateFormat["Short"] = 1] = "Short";
+    DateFormat[DateFormat["Long"] = 2] = "Long";
+    DateFormat[DateFormat["LongWithShortMonth"] = 3] = "LongWithShortMonth";
+    DateFormat[DateFormat["LongWithWeekDay"] = 4] = "LongWithWeekDay";
+    DateFormat[DateFormat["LongWithShortWeekDay"] = 5] = "LongWithShortWeekDay";
+    DateFormat[DateFormat["MonthAndYear"] = 6] = "MonthAndYear";
+    DateFormat[DateFormat["LongMonthAndYear"] = 7] = "LongMonthAndYear";
+    DateFormat[DateFormat["WeekDay"] = 8] = "WeekDay";
+    DateFormat[DateFormat["LongWeekDay"] = 9] = "LongWeekDay";
+    DateFormat[DateFormat["DayAndMonth"] = 10] = "DayAndMonth";
+    DateFormat[DateFormat["ShortUS"] = 11] = "ShortUS";
+    DateFormat[DateFormat["ShortISO8601"] = 12] = "ShortISO8601"; // yyyy-mm-dd
+})(DateFormat || (DateFormat = {}));
+class SystemUtils {
+    /** Shared collator for locale-aware, case-insensitive string comparison. */
+    static { this.collator = new Intl.Collator('it', { sensitivity: 'base', numeric: true }); }
     /**
-     * This check will prevent 'window' logic to be executed
-     * while executing the server rendering
-     * @returns : true if using the browser
+     * Array find by key
+     * @param array     : the array to scan
+     * @param key       : key name
+     * @param value     : the value to search for
+     * @returns         : the property value or null
      */
-    static isBrowser() {
-        return typeof (window) !== 'undefined';
+    static arrayFindByKey(array, key, value) {
+        if (!array)
+            return undefined;
+        for (const item of array) {
+            if (item[key] === value) {
+                return item;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Array find index by key
+     * @param array   : the array to scan
+     * @param key     : the key name
+     * @param value   : the value to search for
+     * @returns       : the array index or -1 if not found
+     */
+    static arrayFindIndexByKey(array, key, value) {
+        if (!array)
+            return -1;
+        for (let i = 0; i < array.length; i++) {
+            if (array[i][key] === value) {
+                return i;
+            }
+        }
+        return -1;
     }
     /**
-     * Convert folders in a tree of Node object.
-     * @param folders : the subfolders group or null to root
-     * @returns       : a node list
+     * Get a value from and array made of name|value items
+     * @param array   : the array to scan
+     * @param value   : the value to search for
+     * @returns       : the property value or null if not found
      */
-    static toNodes(folders) {
-        return this._toNodes(folders, undefined);
+    static arrayGetValue(array, value) {
+        if (!array)
+            return undefined;
+        for (const item of array) {
+            const i = item;
+            if (i['value'] === value) {
+                return i['name'] ?? i['id'];
+            }
+        }
+        return undefined;
     }
     /**
-     * Convert folders in a tree of Node object.
-     * @param folders : the children group or null to root
-     * @param parent  : the parent node
-     * @returns       : a node list
+     * Convert items to nodes into a tree structure
+     * @param items   : list of nodes
+     * @param parent  : parent node
+     * @returns       : an array of INode objects
      */
-    static _toNodes(folders, parent) {
+    static arrayToNodes(items, parent) {
         const nodes = [];
-        folders.forEach((n) => {
+        items.forEach(n => {
             const node = {
-                id: n.id,
+                id: n.id.toString(),
                 name: n.name,
-                count: n.count,
-                parent: parent,
+                count: n.count ? n.count : 0,
                 children: undefined,
+                parent,
                 bag: n,
             };
-            const children = n.children ?? n.subFolders ?? [];
-            if (children.length > 0) {
-                node.children = this._toNodes(children, node);
-            }
             nodes.push(node);
+            node.children =
+                n.children && n.children.length > 0
+                    ? this.arrayToNodes(n.children, node)
+                    : [];
         });
         return nodes;
     }
     /**
-     * Returns an array of individual power-of-2 flag values that are set in `value`.
-     * @param value - The bitmask to decompose.
-     * @param max   - Upper-bound exponent: checks flags from `1` up to `1 << max` (default: `30`).
-     * @returns Array of set flag values, or an empty array when `value` is `0`.
+     * Comparator factory for sorting arrays of objects by a given property key.
+     * Pass the element type for compile-time key checking:
+     * `items.sort(SystemUtils.arraySortCompare<Employee>('lastName'))`.
+     * @param key   - Name of the property to sort by (autocompleted from `T` when provided).
+     * @param order - Sort direction: `'asc'` (default) or `'desc'`.
+     * @returns A comparator function that returns a negative, zero, or positive number.
      */
-    static getFlags(value, max = 30) {
-        if (value !== 0) {
-            const items = [];
-            let v = 1;
-            const m = 1 << max;
-            while (v < m) {
-                if ((value & v) === v)
-                    items.push(v);
-                v = v << 1;
+    static arraySortCompare(key, order = 'asc') {
+        const dir = order === 'desc' ? -1 : 1;
+        return (a, b) => {
+            const varA = a[key];
+            const varB = b[key];
+            if (varA === varB)
+                return 0;
+            if (varA === undefined || varA === null)
+                return -1 * dir;
+            if (varB === undefined || varB === null)
+                return 1 * dir;
+            if (typeof varA === 'string' && typeof varB === 'string') {
+                return SystemUtils.collator.compare(varA, varB) * dir;
             }
-            return items;
-        }
+            return (varA > varB ? 1 : varA < varB ? -1 : 0) * dir;
+        };
+    }
+    /**
+     * Format weight
+     * @param gr    : grams
+     * @returns     : the formatted string
+     */
+    static formatWeight(gr) {
+        if (gr > 1000000)
+            return `${(gr / 1000000).toFixed(2)} t`;
+        else if (gr > 100000)
+            return `${(gr / 100000).toFixed(2)} q`;
+        else if (gr > 1000)
+            return `${(gr / 1000).toFixed(2)} kg`;
         else
-            return [];
+            return `${gr} gr`;
     }
-    /** Cache for resolved color luminance results. */
-    static { this.colorLightCache = new Map(); }
     /**
-     * Check if a color is light or dark
-     * @param color : the color
-     * @param minimumLuminance : the lumimance to consider
-     * @returns true if the color is light
+     * Format file size
+     * @param bytes : number of bytes
+     * @returns     : the formatted string
      */
-    static isColorLight(color, minimumLuminance = 186) {
-        if (!this.isBrowser())
-            return true; // SSR fallback
-        const cacheKey = `${color}|${minimumLuminance}`;
-        const cached = this.colorLightCache.get(cacheKey);
-        if (cached !== undefined)
-            return cached;
-        const tempDiv = document.createElement('div');
-        tempDiv.style.color = color;
-        document.body.appendChild(tempDiv);
-        const rgb = getComputedStyle(tempDiv).color;
-        document.body.removeChild(tempDiv);
-        const result = rgb.match(/\d+/g);
-        let light = true; // fallback
-        if (result && result.length >= 3) {
-            const r = parseInt(result[0], 10);
-            const g = parseInt(result[1], 10);
-            const b = parseInt(result[2], 10);
-            light = (0.299 * r + 0.587 * g + 0.114 * b) > minimumLuminance;
+    static formatFileSize(bytes) {
+        const MB = 1024 * 1024;
+        if (bytes >= MB)
+            return `${(bytes / MB).toFixed(1)} MB`;
+        if (bytes >= 1024)
+            return `${(bytes / 1024).toFixed(1)} KB`;
+        return `${bytes} byte`;
+    }
+    /**
+     * Compare two strings (case-insensitive, locale-aware, accent-insensitive).
+     * @param a   : string a
+     * @param b   : string b
+     * @returns   : 0 if equals, 1 if bigger, -1 if lower
+     */
+    static compareString(a, b) {
+        return this.collator.compare(a ?? '', b ?? '');
+    }
+    /**
+     * Capitalize a string
+     * @param s   : the string to capitalize
+     * @returns   : the capitalized string
+     */
+    static capitalize(s) {
+        if (!s)
+            return undefined;
+        let b = "";
+        let cap = true;
+        for (const char of s) {
+            if (char === " ") {
+                b += char;
+                cap = true;
+            }
+            else if (cap) {
+                b += char.toUpperCase();
+                cap = false;
+            }
+            else {
+                b += char.toLowerCase();
+            }
         }
-        this.colorLightCache.set(cacheKey, light);
-        return light;
+        return b;
+    }
+    /**
+     * Truncate a string at the last word boundary before `max`.
+     * @param s     : the string to truncate
+     * @param max   : the max number of chars
+     * @returns     : the truncated string
+     */
+    static truncate(s, max = 500) {
+        if (!s)
+            return undefined;
+        if (s.length <= max)
+            return s;
+        const i = s.lastIndexOf(' ', max - 1);
+        return i > 0 ? s.slice(0, i) : s;
+    }
+    /**
+     * Join a list of strings
+     * @param items     : the list of strings
+     * @param sep       : the separator string
+     * @param max       : the maximum resulting string
+     * @returns         : the joined string
+     */
+    static join(items, sep = " ", max = 350) {
+        if (!items || items.length === 0)
+            return undefined;
+        if (items.length > 1) {
+            let l = 0;
+            let s = "";
+            while (s.length < max && items.length > l) {
+                if (l > 0) {
+                    s += sep;
+                }
+                s += items[l++];
+            }
+            if (items.length > l) {
+                s += "...";
+            }
+            return s;
+        }
+        return items[0];
+    }
+    /**
+     * Normalize a string by converting it to lowercase and removing extra spaces, with special handling for acronyms and camelCase.
+     * @param s  : the string to normalize
+     * @returns  : The normalized string, or `undefined` if the input is falsy.
+     */
+    static normalizeDisplay(s) {
+        if (!s)
+            return s;
+        return s
+            .split(' ')
+            .map((word, wordIndex) => {
+            if (!word)
+                return word;
+            // If the word is all uppercase and contains at least one letter, we assume it's an acronym and leave it as is
+            if (word === word.toUpperCase() && /[A-Z]/.test(word)) {
+                return word;
+            }
+            // Otherwise, convert to lowercase letter by letter
+            const chars = word.split('');
+            return chars
+                .map((char, charIndex) => {
+                if (charIndex === 0 && wordIndex === 0) {
+                    // First letter of the first word:
+                    // remains uppercase only if the first 2 letters are both uppercase
+                    const secondChar = chars[1] ?? '';
+                    const keepUppercase = char === char.toUpperCase() &&
+                        secondChar === secondChar.toUpperCase() &&
+                        /[A-Z]/.test(char) &&
+                        /[A-Z]/.test(secondChar);
+                    return keepUppercase ? char : char.toLowerCase();
+                }
+                return char.toLowerCase();
+            })
+                .join('');
+        })
+            .join(' ');
+    }
+    /**
+     * Wraps bare URLs in the given string with `<a>` anchor tags.
+     * @param s - The plain-text or HTML string to process.
+     * @returns The string with URLs replaced by clickable links, or `''` when `s` is falsy.
+     */
+    static replaceAsHtml(s) {
+        if (!s)
+            return '';
+        return s.replace(/https?:\/\/[^\s<]+/gi, v => `<a href="${v}" target="_blank" rel="noopener">${v}</a>`);
+    }
+    /**
+     * Convert markdown to html
+     * @param markdown : the markdown data
+     * @param escapeHtml : true to escape HTML. Default is false
+     * @returns the html
+     */
+    static markdownToHtml(markdown, escapeHtml = false) {
+        return MarkdownUtils.toHtml(markdown, { escapeHtml: escapeHtml });
     }
-}
-
-/**
- * General-purpose formatting pipe that converts a raw value to a locale-aware string
- * based on the specified format type.
- *
- * Supported types: `'date'` / `'D'`, `'currency'` / `'C'`, `'number'` / `'N'`,
- * `'number0'` / `'N0'`, `'percentage'` / `'P'`.
- *
- * Usage: `{{ value | format:'currency' }}`
- */
-class FormatPipe {
     /**
-     * Formats a value according to the specified type and optional pattern.
-     * Returns `undefined` when the value is `null` or `undefined`, or when the type is unrecognised.
-     * @param value   - The raw value to format.
-     * @param type    - The format type identifier (default: `'date'`).
-     * @param pattern - The date pattern used when `type` is `'date'` (default: `'dd/MM/yyyy'`).
-     * @returns A formatted string, or `undefined` when the value cannot be formatted.
+     * Compare two names
+     * @param a   : name a
+     * @param b   : name b
+     * @returns   : true if a equals b
      */
-    transform(value, type = 'date', pattern = 'dd/MM/yyyy') {
-        if (value === undefined || value === null)
-            return undefined;
-        switch (type) {
-            case 'D':
-            case 'date': {
-                const d = SystemUtils.parseDate(value, it);
-                if (d)
-                    return format(d, pattern, { locale: it });
-                break;
+    static compareNames(a, b) {
+        if (a)
+            a = a.trim();
+        if (b)
+            b = b.trim();
+        if (a && b && a.length !== b.length)
+            return false;
+        if (this.compareString(a, b) === 0)
+            return true;
+        const p1 = (a ?? '').split(' ');
+        const p2 = (b ?? '').split(' ');
+        if (p1.length !== p2.length)
+            return false;
+        let matches = p1.length;
+        const used = new Array(p2.length).fill(false);
+        for (const s1 of p1) {
+            for (let j = 0; j < p2.length; j++) {
+                if (!used[j] && this.compareString(s1, p2[j]) === 0) {
+                    used[j] = true;
+                    matches--;
+                    break;
+                }
             }
-            case 'C':
-            case 'currency':
-                return new Intl.NumberFormat('it-IT', { style: 'currency', currency: 'EUR' }).format(value);
-            case 'N':
-            case 'number':
-                return new Intl.NumberFormat('it-IT', { style: 'decimal', minimumFractionDigits: 0, maximumFractionDigits: 2 }).format(value);
-            case 'N0':
-            case 'number0':
-                return new Intl.NumberFormat('it-IT', { style: 'decimal', minimumFractionDigits: 0, maximumFractionDigits: 0 }).format(value);
-            case 'P':
-            case 'percentage':
-                return new Intl.NumberFormat('it-IT', { style: 'percent', minimumFractionDigits: 0, maximumFractionDigits: 0 }).format(value);
         }
-        return undefined;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: FormatPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.1", ngImport: i0, type: FormatPipe, isStandalone: true, name: "format" }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: FormatPipe, decorators: [{
-            type: Pipe,
-            args: [{
-                    name: 'format',
-                    standalone: true
-                }]
-        }] });
-
-/**
- * Pipe that applies a global regex replacement on a string and returns the result
- * as sanitized HTML. When `regexValue` is `'\n'` and no `replaceValue` is given,
- * newlines are replaced with `<br>` tags.
- *
- * Usage: `{{ text | replace:'\n':'' }}`
- */
-class ReplacePipe {
-    constructor() {
-        this.sanitizer = inject(DomSanitizer);
+        return matches === 0;
     }
     /**
-     * Replaces all occurrences of `regexValue` in `value` with `replaceValue`.
-     * Returns `undefined` when `value` is empty or `undefined`.
-     * @param value        - The source string to process.
-     * @param regexValue   - The regex pattern string to match (applied with the global flag).
-     * @param replaceValue - The replacement string. Defaults to `'<br>'` when `regexValue` is `'\n'` and this is falsy.
-     * @returns A `SafeHtml` value with all matches replaced, or `undefined` when the input is empty.
+     * Obfuscate a text with a key-driven code point rotation.
+     *
+     * @deprecated This is OBFUSCATION, not cryptography: it hides values from
+     * casual inspection but offers no real security. Use {@link encrypt} /
+     * {@link decrypt} (AES-GCM via Web Crypto) for anything sensitive.
+     *
+     * The rotation operates on Unicode code points and skips the surrogate
+     * range, so the output is always a well-formed string: emoji and other
+     * astral characters round-trip correctly (the previous code-unit based
+     * version could emit lone surrogates and corrupt them).
+     *
+     * BREAKING CHANGE: values encoded with the previous code-unit algorithm
+     * cannot be decoded by this implementation.
+     *
+     * @param text    : the text to encode or decode
+     * @param key     : the key
+     * @param reverse : true to decode, false to encode
+     * @returns       : the obfuscated (or restored) text, or undefined when text/key are empty
      */
-    transform(value, regexValue, replaceValue) {
-        if (!value)
+    static cipher(text, key, reverse = false) {
+        if (!text || !key)
             return undefined;
-        const replacement = (regexValue === '\n' && !replaceValue) ? '<br>' : replaceValue;
-        return this.sanitizer.bypassSecurityTrustHtml(value.replace(new RegExp(regexValue, 'g'), replacement));
+        // Valid Unicode scalar values: [0, 0xD7FF] + [0xE000, 0x10FFFF].
+        // We rotate inside this contiguous "logical" space (surrogates excluded)
+        // so the result is always a valid code point.
+        const SURROGATE_START = 0xd800;
+        const SURROGATE_SIZE = 0x800;
+        const SPACE = 0x110000 - SURROGATE_SIZE; // number of valid scalar values
+        const toIndex = (cp) => (cp < SURROGATE_START ? cp : cp - SURROGATE_SIZE);
+        const toCodePoint = (i) => (i < SURROGATE_START ? i : i + SURROGATE_SIZE);
+        const keyLen = key.length;
+        let result = '';
+        let i = 0;
+        for (const ch of text) { // iterates by code point, not code unit
+            let rotation = key.charCodeAt(i % keyLen);
+            if (reverse)
+                rotation = -rotation;
+            const index = toIndex(ch.codePointAt(0));
+            const rotated = ((index + rotation) % SPACE + SPACE) % SPACE;
+            result += String.fromCodePoint(toCodePoint(rotated));
+            i++;
+        }
+        return result;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: ReplacePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.1", ngImport: i0, type: ReplacePipe, isStandalone: true, name: "replace" }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: ReplacePipe, decorators: [{
-            type: Pipe,
-            args: [{
-                    name: 'replace',
-                    standalone: true
-                }]
-        }] });
-
-/**
- * Pipe that marks an HTML string as trusted so Angular does not escape it when
- * bound via `[innerHTML]`.
- *
- * Usage: `<div [innerHTML]="html | safeHtml"></div>`
- */
-class SafeHtmlPipe {
-    constructor() {
-        this.sanitizer = inject(DomSanitizer);
+    // #region Real encryption (Web Crypto, AES-GCM)
+    /** Payload format version, first byte of the binary envelope. */
+    static { this.CIPHER_VERSION = 1; }
+    /** PBKDF2 salt length in bytes. */
+    static { this.CIPHER_SALT_LENGTH = 16; }
+    /** AES-GCM IV length in bytes (96 bit, the recommended size for GCM). */
+    static { this.CIPHER_IV_LENGTH = 12; }
+    /** PBKDF2-HMAC-SHA-256 iterations (OWASP recommendation). */
+    static { this.CIPHER_ITERATIONS = 600000; }
+    /**
+     * Derives an AES-GCM 256-bit key from a password using PBKDF2-HMAC-SHA-256.
+     * @param password : the user password / passphrase
+     * @param salt     : the random salt bound to this payload
+     * @returns        : a non-extractable AES-GCM CryptoKey
+     */
+    static async deriveKey(password, salt) {
+        const material = await crypto.subtle.importKey('raw', new TextEncoder().encode(password), 'PBKDF2', false, ['deriveKey']);
+        return crypto.subtle.deriveKey({ name: 'PBKDF2', salt: salt, iterations: this.CIPHER_ITERATIONS, hash: 'SHA-256' }, material, { name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt']);
+    }
+    /**
+     * Encodes bytes as URL-safe Base64 (no '+', '/' or trailing '=').
+     * @param bytes : the bytes to encode
+     * @returns     : the base64url string
+     */
+    static toBase64Url(bytes) {
+        let binary = '';
+        const CHUNK = 0x8000;
+        for (let i = 0; i < bytes.length; i += CHUNK) {
+            binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+        }
+        return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+    }
+    /**
+     * Decodes a URL-safe Base64 string back to bytes.
+     * @param value : the base64url string
+     * @returns     : the decoded bytes
+     */
+    static fromBase64Url(value) {
+        const b64 = value.replace(/-/g, '+').replace(/_/g, '/');
+        const padded = b64 + '='.repeat((4 - (b64.length % 4)) % 4);
+        const binary = atob(padded);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++)
+            bytes[i] = binary.charCodeAt(i);
+        return bytes;
+    }
+    /**
+     * Encrypts a text with a password using AES-GCM (256 bit) and a key derived
+     * via PBKDF2-HMAC-SHA-256 with a random per-message salt.
+     *
+     * The result is a self-contained, URL-safe Base64 payload:
+     * `version (1 byte) | salt (16 bytes) | iv (12 bytes) | ciphertext+tag`.
+     * GCM is authenticated: any tampering makes {@link decrypt} fail.
+     *
+     * Requires a secure context (HTTPS or localhost) for `crypto.subtle`.
+     *
+     * @param text     : the plain text to encrypt
+     * @param password : the password / passphrase
+     * @returns        : the base64url payload, or undefined when text/password are
+     *                   empty or the Web Crypto API is unavailable
+     */
+    static async encrypt(text, password) {
+        if (!text || !password)
+            return undefined;
+        if (typeof crypto === 'undefined' || !crypto.subtle)
+            return undefined;
+        try {
+            const salt = crypto.getRandomValues(new Uint8Array(this.CIPHER_SALT_LENGTH));
+            const iv = crypto.getRandomValues(new Uint8Array(this.CIPHER_IV_LENGTH));
+            const key = await this.deriveKey(password, salt);
+            const cipherText = new Uint8Array(await crypto.subtle.encrypt({ name: 'AES-GCM', iv: iv }, key, new TextEncoder().encode(text)));
+            const payload = new Uint8Array(1 + salt.length + iv.length + cipherText.length);
+            payload[0] = this.CIPHER_VERSION;
+            payload.set(salt, 1);
+            payload.set(iv, 1 + salt.length);
+            payload.set(cipherText, 1 + salt.length + iv.length);
+            return this.toBase64Url(payload);
+        }
+        catch {
+            return undefined;
+        }
     }
     /**
-     * Bypasses Angular's HTML sanitization and returns a `SafeHtml` instance.
-     * @param value - The raw HTML string to trust. Treated as an empty string when `undefined`.
-     * @returns A `SafeHtml` value that can be bound to `[innerHTML]` without escaping.
+     * Decrypts a payload produced by {@link encrypt}.
+     * Returns undefined when the password is wrong, the payload was tampered
+     * with, the format is unknown, or the Web Crypto API is unavailable.
+     *
+     * @param payload  : the base64url payload returned by {@link encrypt}
+     * @param password : the password / passphrase used to encrypt
+     * @returns        : the original plain text, or undefined on any failure
      */
-    transform(value) {
-        return this.sanitizer.bypassSecurityTrustHtml(value ?? '');
+    static async decrypt(payload, password) {
+        if (!payload || !password)
+            return undefined;
+        if (typeof crypto === 'undefined' || !crypto.subtle)
+            return undefined;
+        try {
+            const bytes = this.fromBase64Url(payload);
+            const headerLength = 1 + this.CIPHER_SALT_LENGTH + this.CIPHER_IV_LENGTH;
+            if (bytes.length <= headerLength || bytes[0] !== this.CIPHER_VERSION)
+                return undefined;
+            const salt = bytes.subarray(1, 1 + this.CIPHER_SALT_LENGTH);
+            const iv = bytes.subarray(1 + this.CIPHER_SALT_LENGTH, headerLength);
+            const cipherText = bytes.subarray(headerLength);
+            const key = await this.deriveKey(password, salt);
+            const plain = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: iv }, key, cipherText);
+            return new TextDecoder().decode(plain);
+        }
+        catch {
+            // Wrong password or tampered payload: GCM authentication failed
+            return undefined;
+        }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: SafeHtmlPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.1", ngImport: i0, type: SafeHtmlPipe, isStandalone: true, name: "safeHtml" }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: SafeHtmlPipe, decorators: [{
-            type: Pipe,
-            args: [{
-                    name: 'safeHtml',
-                    standalone: true
-                }]
-        }] });
-
-/**
- * Pipe that marks a URL string as a trusted resource URL so Angular does not block it
- * when bound to attributes such as `[src]` or `[href]` on iframes, objects, or embeds.
- *
- * Usage: `<iframe [src]="url | safeUrl"></iframe>`
- */
-class SafeUrlPipe {
-    constructor() {
-        this.sanitizer = inject(DomSanitizer);
+    // #endregion
+    /**
+     * Clone an object (deep copy).
+     * Uses native structuredClone: handles Date, Map, Set, typed arrays and circular references.
+     * @param obj : the object to clone
+     * @returns   : a new object
+     */
+    static clone(obj) {
+        if (obj === null || obj === undefined)
+            return obj;
+        return structuredClone(obj);
     }
     /**
-     * Bypasses Angular's resource-URL sanitization and returns a `SafeResourceUrl` instance.
-     * @param value - The URL string to trust. Treated as an empty string when `undefined`.
-     * @returns A `SafeResourceUrl` that can be bound to resource URL attributes without blocking.
+     * Creates a deep clone of an object.
+     * @param obj  - The source object to clone.
+     * @param dest - Optional pre-allocated destination object to merge the clone into.
+     * @returns A deep copy of `obj`.
      */
-    transform(value) {
-        return this.sanitizer.bypassSecurityTrustResourceUrl(value ?? '');
+    static deepClone(obj, dest) {
+        const cloned = structuredClone(obj);
+        if (dest) {
+            Object.assign(dest, cloned);
+            return dest;
+        }
+        return cloned;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: SafeUrlPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.1", ngImport: i0, type: SafeUrlPipe, isStandalone: true, name: "safeUrl" }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: SafeUrlPipe, decorators: [{
-            type: Pipe,
-            args: [{
-                    name: 'safeUrl',
-                    standalone: true
-                }]
-        }] });
-
-/**
- * Impure pipe that filters an array using a caller-provided predicate function.
- * Because the pipe is impure it re-evaluates on every change-detection cycle,
- * which is necessary when the predicate's captured state changes.
- *
- * Usage: `*ngFor="let item of items | callback:myFilter"`
- */
-class SearchCallbackPipe {
     /**
-     * Filters `items` by applying `callback` to each element.
-     * Returns the original array unchanged when either argument is falsy.
-     * @param items    - The source array to filter. May be `undefined`.
-     * @param callback - A predicate function that returns `true` for items to keep.
-     * @returns A new filtered array, the original array when no callback is provided,
-     *          or `undefined` when `items` is `undefined`.
+     * Returns `true` when `value` is a syntactically valid UUID string.
+     * @param value - The string to validate.
      */
-    transform(items, callback) {
-        if (!items || !callback)
-            return items;
-        return items.filter(item => callback(item));
+    static parseUUID(value) {
+        if (!value)
+            return false;
+        let s = value.trim();
+        // Strip a matching wrapper pair, if present
+        if ((s.startsWith('{') && s.endsWith('}')) || (s.startsWith('(') && s.endsWith(')'))) {
+            s = s.slice(1, -1);
+        }
+        return /^[0-9a-fA-F]{8}-(?:[0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}$/.test(s);
+    }
+    /**
+     * Returns `true` when `value` is a valid, non-empty (non-zero) UUID.
+     * @param value - The string to validate.
+     */
+    static parseUUIDNotEmpty(value) {
+        return this.parseUUID(value) && !/^[{(]?0{8}-(?:0{4}-){3}0{12}[)}]?$/.test((value ?? '').trim());
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: SearchCallbackPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.1", ngImport: i0, type: SearchCallbackPipe, isStandalone: true, name: "callback", pure: false }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: SearchCallbackPipe, decorators: [{
-            type: Pipe,
-            args: [{
-                    name: 'callback',
-                    pure: false,
-                    standalone: true
-                }]
-        }] });
-
-/**
- * Impure pipe that filters an array of searchable items against a text query.
- *
- * Each item is matched either via its `searchBag.name` property (when present)
- * or by converting the item itself to a lowercase string. The optional `metadata`
- * argument is updated in-place with the total item count and the filtered count,
- * making it usable in the template alongside `*ngFor`.
- *
- * Usage:
- * ```html
- * <div *ngFor="let item of items | search:filterText:meta">...</div>
- * <div>Showing {{ meta.count }} of {{ meta.total }}</div>
- * ```
- */
-class SearchFilterPipe {
     /**
-     * Filters `items` by performing a case-insensitive substring match against `value`.
-     * When `items` or `value` is falsy the original array is returned unfiltered.
-     * @param items    - The source array to filter. May be `undefined`.
-     * @param value    - The search text to match against each item. May be `undefined`.
-     * @param metadata - Optional object that is updated with `total` and `count` after filtering.
-     * @returns The filtered array, the original array when no filter text is given,
-     *          or `undefined` when `items` is `undefined`.
+     * Return an empty UUID
+     * @returns : the empty UUID
      */
-    transform(items, value, metadata) {
-        metadata ??= { total: 0, count: 0 };
-        if (!items || !value)
-            return items;
-        const query = value.toLowerCase();
-        const result = items.filter(item => {
-            if (!item)
-                return false;
-            const text = item.searchBag?.name ?? (typeof item === 'string' ? item : undefined);
-            return text?.toLowerCase().includes(query) ?? false;
+    static emptyUUID() { return "00000000-0000-0000-0000-000000000000"; }
+    ;
+    /**
+     * Create a new UUID
+     * @returns : the string UUID
+     */
+    static generateUUID() {
+        if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+            return crypto.randomUUID();
+        }
+        // Fallback (non-secure contexts)
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+            const r = (Math.random() * 16) | 0;
+            const v = c === 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
         });
-        metadata.total = items.length;
-        metadata.count = result.length;
-        return result;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: SearchFilterPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.1", ngImport: i0, type: SearchFilterPipe, isStandalone: true, name: "search" }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: SearchFilterPipe, decorators: [{
-            type: Pipe,
-            args: [{
-                    name: 'search',
-                    standalone: true
-                }]
-        }] });
-
-/**
- * Pipe that converts plain-text newlines (`\r\n`, `\r`, `\n`) to HTML `<br>` tags
- * and marks the result as trusted HTML so Angular does not escape it.
- *
- * Usage: `{{ text | formatHtml }}`
- */
-class FormatHtmlPipe {
-    constructor() {
-        this.sanitizer = inject(DomSanitizer);
+    /**
+     * Reconstruct a standard UUID (with dashes) from a 32-char hex string without dashes.
+     * @param value : 32-character hex string
+     * @returns     : the formatted UUID or the original string if it doesn't match the expected format
+     */
+    static inflateUUID(value) {
+        const s = value.trim();
+        if (s.length !== 32)
+            return s;
+        return `${s.slice(0, 8)}-${s.slice(8, 12)}-${s.slice(12, 16)}-${s.slice(16, 20)}-${s.slice(20)}`;
     }
+    /** Precompiled validation patterns. */
+    static { this.emailRegex = /^(?:[a-z0-9+!#$%&'*+\/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+\/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])$/i; }
+    static { this.urlRegex = /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,12})(:\d{1,5})?([/\w .%-]*)?(\?[^\s#]*)?(#\S*)?$/i; }
     /**
-     * Transforms a plain-text string into sanitized HTML by replacing newline characters
-     * with `<br>` tags.
-     * @param value - The input string to transform. Treated as an empty string when `undefined`.
-     * @returns A `SafeHtml` value that can be rendered with `[innerHTML]`.
+     * Parse a text and return true if it is a valid email (or empty)
+     * @param value : email
+     * @returns     : true if the email is valid or empty
      */
-    transform(value) {
-        return this.sanitizer.bypassSecurityTrustHtml((value ?? '').replaceAll(/(?:\r\n|\r|\n)/g, '<br>'));
+    static parseEmail(value) {
+        if (!value)
+            return true;
+        return this.emailRegex.test(value.trim().toLowerCase());
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: FormatHtmlPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.1", ngImport: i0, type: FormatHtmlPipe, isStandalone: true, name: "formatHtml" }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: FormatHtmlPipe, decorators: [{
-            type: Pipe,
-            args: [{
-                    name: 'formatHtml',
-                    standalone: true
-                }]
-        }] });
-
-/**
- * Standalone providers for the ars-utils "core" layer.
- *
- * Registers the core pipes as injectable services so they can be used
- * via `inject()` in services, guards, and resolvers — not only in templates.
- * Components that use these pipes only in templates should import them
- * directly via `imports: [FormatPipe, SafeHtmlPipe, ...]` instead.
- *
- * @example
- * bootstrapApplication(AppComponent, {
- *   providers: [provideArsCore()]
- * });
- */
-function provideArsCore() {
-    return makeEnvironmentProviders([
-        SearchFilterPipe,
-        SearchCallbackPipe,
-        SafeHtmlPipe,
-        SafeUrlPipe,
-        ReplacePipe,
-        FormatPipe,
-        FormatHtmlPipe
-    ]);
-}
-
-/**
- * Creates an array of the given length, filling each slot with the result of `valueFunction`.
- * @param length        - Number of elements to create.
- * @param valueFunction - Factory called with each index to produce the element value.
- * @returns Typed array of `length` elements.
- */
-function range(length, valueFunction) {
-    const valuesArray = Array(length);
-    for (let i = 0; i < length; i++) {
-        valuesArray[i] = valueFunction(i);
+    /**
+     * Parse a text containing one or more email addresses separated by `;` or `,`
+     * and return true if all of them are valid (or the text is empty).
+     * Empty items caused by double or trailing separators are ignored.
+     * @param value : the email list to parse (e.g. "a@b.it; c@d.it")
+     * @returns     : true if all emails are valid or the value is empty
+     */
+    static parseEmails(value) {
+        if (!value || value.trim().length === 0)
+            return true;
+        const items = value
+            .split(/[;,]/)
+            .map(e => e.trim().toLowerCase())
+            .filter(e => e.length > 0);
+        if (items.length === 0)
+            return false; // only separators, no addresses
+        return items.every(e => this.emailRegex.test(e));
     }
-    return valuesArray;
-}
-// date-fns doesn't have a way to read/print month names or days of the week directly,
-// so we get them by formatting a date with a format that produces the desired month/day.
-const MONTH_FORMATS = {
-    long: 'LLLL',
-    short: 'LLL',
-    narrow: 'LLLLL',
-};
-const DAY_OF_WEEK_FORMATS = {
-    long: 'EEEE',
-    short: 'EEE',
-    narrow: 'EEEEE',
-};
-const MAT_DATE_FNS_FORMATS = {
-    parse: {
-        dateInput: 'P',
-    },
-    display: {
-        dateInput: 'P',
-        monthYearLabel: 'LLL uuuu',
-        dateA11yLabel: 'PP',
-        monthYearA11yLabel: 'LLLL uuuu',
-    },
-};
-/**
- * date-fns adapter that integrates Angular Material's date picker with the date-fns library,
- * applying `Europe/Rome` timezone for all parsed and created dates.
- */
-class DateFnsAdapter extends DateAdapter {
-    constructor() {
-        super();
-        const matDateLocale = inject(MAT_DATE_LOCALE, { optional: true });
-        if (matDateLocale) {
-            this.setLocale(matDateLocale);
+    /**
+     * Parse a text and return true if it is a valid url (or empty)
+     * @param value : the url to parse
+     * @returns     : true if the url is valid or empty
+     */
+    static parseUrl(value) {
+        if (!value)
+            return true;
+        return this.urlRegex.test(value.trim().toLowerCase());
+    }
+    /**
+     * Get date parts from a string value
+     * @param value   : the string to parse
+     * @returns       : an array of numbers with year, month, day
+     */
+    static getDateParts(value) {
+        if (!value)
+            return undefined;
+        let parts = [];
+        if (value.indexOf("-") !== -1) {
+            const p = value.split("-");
+            if (p.length !== 3)
+                return undefined;
+            parts = [parseInt(p[0]), parseInt(p[1]) - 1, parseInt(p[2])];
+        }
+        else if (value.indexOf("/") !== -1) {
+            const p = value.split("/");
+            if (p.length !== 3)
+                return undefined;
+            parts = [parseInt(p[2]), parseInt(p[1]) - 1, parseInt(p[0])];
+        }
+        else {
+            return undefined;
         }
+        return parts;
     }
     /**
-     * Returns the year component of the given date.
-     * @param date - The source date.
+     * Checks whether a value is a valid Date instance.
+     * Note: do not use `date.getTime()` as a truthiness test, it is 0 (falsy)
+     * for the Unix epoch (1970-01-01T00:00:00Z) even though the date is valid.
+     * @param d : the value to check
+     * @returns : true when `d` is a Date representing a valid point in time
      */
-    getYear(date) {
-        return getYear(date);
+    static isValidDate(d) {
+        return d instanceof Date && !isNaN(d.getTime());
     }
     /**
-     * Returns the zero-based month index of the given date (0 = January).
-     * @param date - The source date.
+     * Parse a date
+     * @param value   : the value to check
+     * @param locale  : the locale to use
+     * @returns       : a valid Date object or undefined
      */
-    getMonth(date) {
-        return getMonth(date);
+    static parseDate(value, locale = it) {
+        // No value at all
+        if (!value)
+            return undefined;
+        // A Date value
+        if (value instanceof Date)
+            return this.isValidDate(value) ? value : undefined;
+        // Parse known formats using date-fns
+        let d = parseISO(value);
+        if (this.isValidDate(d) && d.getFullYear() > 1750)
+            return d;
+        d = parse(value, 'dd/MM/yyyy', new Date(), { locale: locale });
+        if (this.isValidDate(d) && d.getFullYear() > 1750)
+            return d;
+        d = parse(value, 'yyyy-MM-dd', new Date(), { locale: locale });
+        if (this.isValidDate(d) && d.getFullYear() > 1750)
+            return d;
+        // Parse values manually
+        const parts = this.getDateParts(value);
+        if (!parts)
+            return undefined;
+        if (parts[0] < 100)
+            parts[0] += 2000;
+        if (isNaN(parts[0]) || parts[0] < 0 || parts[0] < 1750)
+            return undefined;
+        if (isNaN(parts[1]) || parts[1] < 0)
+            return undefined;
+        if (isNaN(parts[2]) || parts[2] < 0)
+            return undefined;
+        if (parts[1] > 11)
+            return undefined;
+        if (parts[1] === 1 && parts[2] > 29)
+            return undefined;
+        else if (parts[1] !== 1 && parts[2] > 31)
+            return undefined;
+        return new TZDate(parts[0], parts[1], parts[2], 12);
     }
     /**
-     * Returns the day-of-month of the given date (1-based).
-     * @param date - The source date.
+     * Format a date
+     * @param value     : the date or string to format
+     * @param fmt       : the DateFormat to use or the string pattern
+     * @param locale    : the locale to use (default is IT)
+     * @returns         : the formatted string
      */
-    getDate(date) {
-        return getDate(date);
+    static formatDate(value, fmt = DateFormat.Short, locale = it) {
+        // No value at all
+        if (!value)
+            return '';
+        // A string
+        if (typeof value === 'string' || value instanceof String)
+            value = this.parseDate(value);
+        // Not a date
+        if (!this.isValidDate(value))
+            return '';
+        // Format
+        switch (fmt) {
+            case DateFormat.Short: return format(value, "dd/MM/yyyy", { locale: locale });
+            case DateFormat.Long: return format(value, "d MMMM yyyy", { locale: locale });
+            case DateFormat.LongWithShortMonth: return format(value, "d MMM yyyy", { locale: locale });
+            case DateFormat.LongWithWeekDay: return format(value, "EEEE, d MMMM yyyy", { locale: locale });
+            case DateFormat.LongWithShortWeekDay: return format(value, "EEE, d MMMM yyyy", { locale: locale });
+            case DateFormat.MonthAndYear: return format(value, "MMM yyyy", { locale: locale });
+            case DateFormat.LongMonthAndYear: return format(value, "MMMM yyyy", { locale: locale });
+            case DateFormat.WeekDay: return format(value, "EEE, d", { locale: locale });
+            case DateFormat.LongWeekDay: return format(value, "EEEE, d", { locale: locale });
+            case DateFormat.DayAndMonth: return format(value, "d MMMM", { locale: locale });
+            case DateFormat.ShortUS: return format(value, "MM/dd/yyyy", { locale: locale });
+            case DateFormat.ShortISO8601: return format(value, "yyyy-MM-dd", { locale: locale });
+            default:
+                return format(value, fmt, { locale: locale });
+        }
     }
     /**
-     * Returns the day-of-week of the given date (0 = Sunday).
-     * @param date - The source date.
+     * Return an italian local date
+     * @param value  : the date
+     * @returns     : the new date
      */
-    getDayOfWeek(date) {
-        return getDay(date);
+    static toLocalDate(value) {
+        // No value at all
+        if (!value)
+            return undefined;
+        // A string
+        if (typeof value === 'string' || value instanceof String)
+            value = this.parseDate(value);
+        // Not a date
+        if (!this.isValidDate(value))
+            return undefined;
+        // Update date
+        return new TZDate(value, "Europe/Rome");
     }
     /**
-     * Returns an array of 12 month name strings formatted for the active locale.
-     * @param style - One of `'long'`, `'short'`, or `'narrow'`.
+     * Update a DateInterval object according to a string
+     * @param value       : string value
+     * @param interval    : DateInterval value to update
+     * @param end         : true if must be updated the first or the end value
+     * @param copy        : copy the same value (works only if not end element)
      */
-    getMonthNames(style) {
-        const pattern = MONTH_FORMATS[style];
-        return range(12, i => this.format(new Date(2017, i, 1), pattern));
+    static changeDateInterval(value, interval, end = false, copy = false) {
+        if (value) {
+            let year = -1;
+            if (value.length === 4 && (year = parseInt(value)) > 1750) {
+                if (!end) {
+                    interval.from = new TZDate(new Date(year, 0, 1), 'Europe/Rome');
+                    interval.to = new TZDate(new Date(year, 11, 31), 'Europe/Rome');
+                }
+                else
+                    interval.to = new Date(year, 11, 31);
+            }
+            else {
+                const parts = this.getDateParts(value);
+                if (!parts || parts.length !== 3)
+                    return;
+                if (isNaN(parts[0]) || parts[0] < 1750)
+                    return;
+                if (isNaN(parts[1]) || parts[1] < 0 || parts[1] > 11)
+                    return;
+                if (isNaN(parts[2]) || parts[2] < 1 || parts[2] > 31)
+                    return;
+                const d = new TZDate(new Date(parts[0], parts[1], parts[2]), 'Europe/Rome');
+                if (end)
+                    interval.to = d;
+                else if (copy) {
+                    interval.from = d;
+                    interval.to = d;
+                }
+                else
+                    interval.from = d;
+            }
+        }
     }
+    /** Cache of `Intl.NumberFormat` instances (their construction is expensive). */
+    static { this.numberFormatCache = new Map(); }
     /**
-     * Returns an array of 31 day-of-month label strings formatted using `Intl.DateTimeFormat`
-     * when available, falling back to plain numeric strings.
+     * Returns a cached `Intl.NumberFormat` for the given options, creating it on first use.
+     * @param locale  - BCP 47 locale tag.
+     * @param options - The `Intl.NumberFormat` options.
+     * @returns A shared formatter instance.
      */
-    getDateNames() {
-        const dtf = typeof Intl !== 'undefined'
-            ? new Intl.DateTimeFormat(this.locale?.code, {
-                day: 'numeric',
-                timeZone: 'utc',
-            })
-            : null;
-        return range(31, i => {
-            if (dtf) {
-                // date-fns doesn't appear to support this functionality.
-                // Fall back to `Intl` on supported browsers.
-                const date = new Date();
-                date.setUTCFullYear(2017, 0, i + 1);
-                date.setUTCHours(0, 0, 0, 0);
-                return dtf.format(date).replace(/[\u200e\u200f]/g, '');
-            }
-            return String(i + 1);
-        });
+    static getNumberFormat(locale, options) {
+        const key = `${locale}|${options.style}|${options.currency ?? ''}|${options.minimumFractionDigits}|${options.maximumFractionDigits}`;
+        let fmt = this.numberFormatCache.get(key);
+        if (!fmt) {
+            fmt = new Intl.NumberFormat(locale, options);
+            this.numberFormatCache.set(key, fmt);
+        }
+        return fmt;
     }
     /**
-     * Returns an array of 7 day-of-week name strings formatted for the active locale.
-     * @param style - One of `'long'`, `'short'`, or `'narrow'`.
+     * Formats a number using a cached `Intl.NumberFormat`.
+     * @param value    - The number to format.
+     * @param decimals - Maximum decimal places (default: `2`).
+     * @param locale   - BCP 47 locale tag (default: `'it-IT'`).
+     * @returns The formatted number string.
      */
-    getDayOfWeekNames(style) {
-        const pattern = DAY_OF_WEEK_FORMATS[style];
-        return range(7, i => this.format(new Date(2017, 0, i + 1), pattern));
+    static formatNumber(value, decimals = 2, locale = 'it-IT') {
+        return this.getNumberFormat(locale, { style: 'decimal', minimumFractionDigits: 0, maximumFractionDigits: decimals }).format(value);
     }
     /**
-     * Returns the four-digit year string for the given date.
-     * @param date - The source date.
+     * Formats a number as a currency string using a cached `Intl.NumberFormat`.
+     * @param value    - The number to format.
+     * @param currency - ISO 4217 currency code (default: `'EUR'`).
+     * @param decimals - Maximum decimal places (default: `2`).
+     * @param locale   - BCP 47 locale tag (default: `'it-IT'`).
+     * @returns The formatted currency string.
      */
-    getYearName(date) {
-        return this.format(date, 'y');
+    static formatCurrency(value, currency = 'EUR', decimals = 2, locale = 'it-IT') {
+        return this.getNumberFormat(locale, { style: 'currency', currency, minimumFractionDigits: 0, maximumFractionDigits: decimals }).format(value);
     }
     /**
-     * Returns the first day of the week for the active locale (0 = Sunday, 1 = Monday, …).
+     * Percent-encodes a string for safe inclusion in a URL.
+     * @param value - The string to encode.
+     * @returns The encoded string, or `undefined` when `value` is empty.
      */
-    getFirstDayOfWeek() {
-        return this.locale?.options?.weekStartsOn ?? 0;
+    static urlEncode(value) {
+        return value.length > 0
+            ? encodeURIComponent(value)
+            : undefined;
     }
     /**
-     * Returns the number of days in the month of the given date.
-     * @param date - The source date.
+     * Decodes a percent-encoded URL string, treating `+` as a space.
+     * @param value - The encoded string to decode.
+     * @returns The decoded string, or `undefined` when `value` is empty or absent.
      */
-    getNumDaysInMonth(date) {
-        return getDaysInMonth(date);
+    static urlDecode(value) {
+        return value && value.length > 0
+            ? decodeURIComponent(value.replace(/\+/g, '%20'))
+            : undefined;
     }
     /**
-     * Creates an independent copy of the given date.
-     * @param date - The date to clone.
+     * Reads a query string parameter value from the current page URL.
+     * @param name - The parameter name to look up.
+     * @returns The decoded parameter value, or `undefined` when absent or running server-side.
      */
-    clone(date) {
-        return new Date(date.getTime());
+    static getQueryStringValueByName(name) {
+        if (!this.isBrowser())
+            return undefined;
+        const v = new URLSearchParams(window.location.search).get(name);
+        return v && v !== 'null' ? v : undefined;
     }
     /**
-     * Creates a `Date` in the `Europe/Rome` timezone for the given year, month, and day.
-     * Throws an `Error` when any component is out of range.
-     * @param year  - Full four-digit year.
-     * @param month - Zero-based month index (0 = January, 11 = December).
-     * @param date  - Day-of-month (1-based).
+     * Generate a password
+     * @returns : the password string
      */
-    createDate(year, month, date) {
-        if (month < 0 || month > 11) {
-            throw Error(`Invalid month index "${month}". Month index has to be between 0 and 11.`);
-        }
-        if (date < 1) {
-            throw Error(`Invalid date "${date}". Date has to be greater than 0.`);
+    static generatePassword(length = 12) {
+        const lower = 'abcdefghijkmnopqrstuvwxyz'; // no 'l' (ambiguous)
+        const upper = 'ABCDEFGHJKLMNPQRSTUVWXYZ'; // no 'I'/'O' (ambiguous)
+        const digits = '23456789'; // no '0'/'1' (ambiguous)
+        const symbols = '$!#%&*+-';
+        const all = lower + upper + digits + symbols;
+        // Secure random indices (crypto is available in browsers and Node)
+        const rnd = (max) => {
+            if (typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function') {
+                const buf = new Uint32Array(1);
+                crypto.getRandomValues(buf);
+                return buf[0] % max;
+            }
+            return Math.floor(Math.random() * max);
+        };
+        // Guarantee at least one char per class, fill the rest, then shuffle
+        const chars = [
+            lower[rnd(lower.length)],
+            upper[rnd(upper.length)],
+            digits[rnd(digits.length)],
+            symbols[rnd(symbols.length)],
+        ];
+        while (chars.length < Math.max(length, 8)) {
+            chars.push(all[rnd(all.length)]);
         }
-        // Passing the year to the constructor causes year numbers <100 to be converted to 19xx.
-        // To work around this we use `setFullYear` and `setHours` instead.
-        const result = new Date();
-        result.setFullYear(year, month, date);
-        result.setHours(0, 0, 0, 0);
-        const result2 = new TZDate(result, 'Europe/Rome');
-        if (result2.getMonth() !== month) {
-            throw Error(`Invalid date "${date}" for month with index "${month}".`);
+        for (let i = chars.length - 1; i > 0; i--) {
+            const j = rnd(i + 1);
+            [chars[i], chars[j]] = [chars[j], chars[i]];
         }
-        return result2;
-    }
-    /**
-     * Returns today's date in the local timezone.
-     */
-    today() {
-        return new Date();
+        return chars.join('');
     }
     /**
-     * Parses a value into a `Date`.
-     * - Strings are first attempted as ISO 8601, then matched against each format in `parseFormat`.
-     * - Numbers are treated as Unix timestamps (milliseconds).
-     * - Existing `Date` instances are cloned.
-     * @param value       - The value to parse.
-     * @param parseFormat - A format string or an array of format strings (date-fns tokens).
-     * @returns A valid `Date` in `Europe/Rome`, an invalid sentinel, or `null` for unrecognised input.
+     * Calculate password strength
+     * @param password: the password to evaluate
+     * @returns the password strength info
      */
-    parse(value, parseFormat) {
-        if (typeof value === 'string' && value.length > 0) {
-            const iso8601Date = parseISO(value);
-            if (this.isValid(iso8601Date)) {
-                return new TZDate(iso8601Date, 'Europe/Rome');
+    static calculatePasswordStrength(password) {
+        if (password && password.length > 0) {
+            let score = 0;
+            const suggestions = [];
+            // Length
+            if (password.length >= 10)
+                score++;
+            else
+                suggestions.push('Usa almeno 10 caratteri.');
+            if (password.length >= 12)
+                score++;
+            else if (password.length >= 10)
+                suggestions.push('Considera di usare più di 12 caratteri.');
+            // Lowercase letters
+            if (/[a-z]/.test(password))
+                score++;
+            else
+                suggestions.push('Aggiungi lettere minuscole.');
+            // Uppercase letters
+            if (/[A-Z]/.test(password))
+                score++;
+            else
+                suggestions.push('Aggiungi lettere maiuscole.');
+            // Numbers
+            if (/\d/.test(password))
+                score++;
+            else
+                suggestions.push('Aggiungi numeri.');
+            // Special characters
+            if (/[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]/.test(password))
+                score++;
+            else
+                suggestions.push('Aggiungi caratteri speciali (!@#$%^&*).');
+            // Common patterns
+            if (/(.)\1{2,}/.test(password)) {
+                score = Math.max(0, score - 1);
+                suggestions.push('Evita di ripetere lo stesso carattere.');
             }
-            const formats = Array.isArray(parseFormat) ? parseFormat : [parseFormat];
-            if (!formats.length) {
-                throw Error('Formats array must not be empty.');
+            if (/123|abc|qwe/i.test(password)) {
+                score = Math.max(0, score - 1);
+                suggestions.push('Evita sequenze comuni (123, abc, qwe).');
+            }
+            // Label and color
+            let label;
+            let color;
+            let isValid;
+            if (score <= 2) {
+                label = 'Molto debole';
+                color = '#f44336';
+                isValid = false;
+            }
+            else if (score <= 3) {
+                label = 'Debole';
+                color = '#ff9800';
+                isValid = false;
+            }
+            else if (score <= 4) {
+                label = 'Media';
+                color = '#ffc107';
+                isValid = true;
             }
-            for (const currentFormat of formats) {
-                const fromFormat = parse(value, currentFormat, new Date(), { locale: this.locale });
-                if (this.isValid(fromFormat)) {
-                    return new TZDate(fromFormat, 'Europe/Rome');
-                }
+            else if (score <= 5) {
+                label = 'Forte';
+                color = '#8bc34a';
+                isValid = true;
             }
-            return this.invalid();
-        }
-        else if (typeof value === 'number') {
-            return new Date(value);
-        }
-        else if (value instanceof Date) {
-            return this.clone(value);
-        }
-        return null;
-    }
-    /**
-     * Formats a `Date` using the given date-fns display format string.
-     * Throws an `Error` when `date` is not valid.
-     * @param date          - The date to format.
-     * @param displayFormat - A date-fns format string (e.g. `'P'`, `'LLL uuuu'`).
-     */
-    format(date, displayFormat) {
-        if (!this.isValid(date)) {
-            throw Error('DateFnsAdapter: Cannot format invalid date.');
+            else {
+                label = 'Molto forte';
+                color = '#4caf50';
+                isValid = true;
+            }
+            return { score, label, color, suggestions, isValid };
         }
-        return format(date, displayFormat, { locale: this.locale });
+        else
+            return {
+                score: 0,
+                isValid: false,
+                suggestions: []
+            };
     }
     /**
-     * Adds the given number of whole years to a date.
-     * @param date  - The base date.
-     * @param years - Number of years to add (can be negative).
+     * Check if current browser supports touch
+     * @returns : true if the display is touchable
      */
-    addCalendarYears(date, years) {
-        return addYears(date, years);
+    static isTouchable() {
+        return (this.isBrowser() && ("ontouchstart" in window ||
+            navigator.maxTouchPoints > 0));
     }
     /**
-     * Adds the given number of whole months to a date.
-     * @param date   - The base date.
-     * @param months - Number of months to add (can be negative).
+     * This check will prevent 'window' logic to be executed
+     * while executing the server rendering
+     * @returns : true if using the browser
      */
-    addCalendarMonths(date, months) {
-        return addMonths(date, months);
+    static isBrowser() {
+        return typeof (window) !== 'undefined';
     }
     /**
-     * Adds the given number of whole days to a date.
-     * @param date - The base date.
-     * @param days - Number of days to add (can be negative).
+     * Convert folders in a tree of Node object.
+     * @param folders : the subfolders group or null to root
+     * @returns       : a node list
      */
-    addCalendarDays(date, days) {
-        return addDays(date, days);
+    static toNodes(folders) {
+        return this._toNodes(folders, undefined);
     }
     /**
-     * Serialises a date to an ISO 8601 date string (`yyyy-MM-dd`).
-     * @param date - The date to serialise.
+     * Convert folders in a tree of Node object.
+     * @param folders : the children group or null to root
+     * @param parent  : the parent node
+     * @returns       : a node list
      */
-    toIso8601(date) {
-        return formatISO(date, { representation: 'date' });
+    static _toNodes(folders, parent) {
+        const nodes = [];
+        folders.forEach((n) => {
+            const node = {
+                id: n.id,
+                name: n.name,
+                count: n.count,
+                parent: parent,
+                children: undefined,
+                bag: n,
+            };
+            const children = n.children ?? n.subFolders ?? [];
+            if (children.length > 0) {
+                node.children = this._toNodes(children, node);
+            }
+            nodes.push(node);
+        });
+        return nodes;
     }
     /**
-     * Returns the given value when it is a valid `Date`, or `null` for an empty string.
-     * Deserialises valid ISO 8601 strings into `Date` instances.
-     * Delegates all other values to the base-class implementation.
-     * @param value - The raw value to deserialise.
+     * Returns an array of individual power-of-2 flag values that are set in `value`.
+     * @param value - The bitmask to decompose.
+     * @param max   - Upper-bound exponent: checks flags from `1` up to `1 << max` (default: `30`).
+     * @returns Array of set flag values, or an empty array when `value` is `0`.
      */
-    deserialize(value) {
-        if (typeof value === 'string') {
-            if (!value) {
-                return null;
-            }
-            const date = parseISO(value);
-            if (this.isValid(date)) {
-                return date;
+    static getFlags(value, max = 30) {
+        if (value !== 0) {
+            const items = [];
+            const top = Math.min(max, 30); // beyond 30 the shift overflows into the sign bit
+            for (let exp = 0; exp <= top; exp++) {
+                const v = 1 << exp;
+                if ((value & v) === v)
+                    items.push(v);
             }
+            return items;
         }
-        return super.deserialize(value);
-    }
-    /**
-     * Returns `true` when `obj` is an instance of `Date`.
-     * @param obj - The object to test.
-     */
-    isDateInstance(obj) {
-        return isDate(obj);
-    }
-    /**
-     * Returns `true` when `date` represents a valid point in time.
-     * @param date - The date to validate.
-     */
-    isValid(date) {
-        return isValid(date);
+        else
+            return [];
     }
+    /** Cache for resolved color luminance results. */
+    static { this.colorLightCache = new Map(); }
     /**
-     * Returns a sentinel `Date` that represents an invalid date (`new Date(NaN)`).
+     * Check if a color is light or dark
+     * @param color : the color
+     * @param minimumLuminance : the lumimance to consider
+     * @returns true if the color is light
      */
-    invalid() {
-        return new Date(NaN);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: DateFnsAdapter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: DateFnsAdapter }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: DateFnsAdapter, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-/**
- * Standalone providers for the ars-utils date-fns adapter.
- *
- * Configures Angular Material to use {@link DateFnsAdapter} (Europe/Rome timezone)
- * and the matching {@link MAT_DATE_FNS_FORMATS}.
- *
- * @example
- * bootstrapApplication(AppComponent, {
- *   providers: [provideArsDateFns()]
- * });
- */
-function provideArsDateFns() {
-    return makeEnvironmentProviders([
-        {
-            provide: DateAdapter,
-            useClass: DateFnsAdapter,
-            deps: [MAT_DATE_LOCALE],
-        },
-        { provide: MAT_DATE_FORMATS, useValue: MAT_DATE_FNS_FORMATS }
-    ]);
-}
-
-/**
- * Directive that moves browser focus to the host element after the first render cycle.
- * Apply `autoFocus` to any focusable element to set focus automatically on initialisation.
- */
-class AutoFocusDirective {
-    constructor() {
-        this.elementRef = inject(ElementRef);
-        afterNextRender(() => {
-            this.elementRef.nativeElement?.focus();
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: AutoFocusDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.1", type: AutoFocusDirective, isStandalone: true, selector: "[autoFocus]", ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: AutoFocusDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[autoFocus]',
-                    standalone: true
-                }]
-        }], ctorParameters: () => [] });
-
-class FileInfo {
-    isValid() {
-        return this.valid;
-    }
-}
-class ValueModel {
-}
-class IDModel {
-}
-class GroupModel {
-}
-class DeleteModel extends GroupModel {
-}
-class RelationModel {
-}
-class UpdateRelationsModel {
-}
-class QueryModel {
-}
-class ImportModel {
-}
-class DateInterval {
-    get fromAsDate() {
-        if (this.from) {
-            if (!(this.from instanceof Date)) {
-                this.from = new Date(this.from);
-            }
-            if (this.from) {
-                return new Date(this.from.getFullYear(), this.from.getMonth(), this.from.getDate(), 2, 0, 0);
-            }
-        }
-        return undefined;
-    }
-    get toAsDate() {
-        if (this.to) {
-            if (!(this.to instanceof Date)) {
-                this.to = new Date(this.to);
-            }
-            if (this.to) {
-                return new Date(this.to.getFullYear(), this.to.getMonth(), this.to.getDate(), 2, 0, 0);
-            }
-        }
-        return undefined;
-    }
-    constructor(from, to) {
-        this.from = from;
-        this.to = to;
-    }
-    clear() {
-        this.from = undefined;
-        this.to = undefined;
+    static isColorLight(color, minimumLuminance = 186) {
+        if (!this.isBrowser())
+            return true; // SSR fallback
+        const cacheKey = `${color}|${minimumLuminance}`;
+        const cached = this.colorLightCache.get(cacheKey);
+        if (cached !== undefined)
+            return cached;
+        const tempDiv = document.createElement('div');
+        tempDiv.style.color = color;
+        document.body.appendChild(tempDiv);
+        const rgb = getComputedStyle(tempDiv).color;
+        document.body.removeChild(tempDiv);
+        const result = rgb.match(/\d+/g);
+        let light = true; // fallback
+        if (result && result.length >= 3) {
+            const r = parseInt(result[0], 10);
+            const g = parseInt(result[1], 10);
+            const b = parseInt(result[2], 10);
+            light = (0.299 * r + 0.587 * g + 0.114 * b) > minimumLuminance;
+        }
+        this.colorLightCache.set(cacheKey, light);
+        return light;
     }
 }
 
@@ -2097,7 +2014,7 @@ class DateInterval {
 class DateIntervalChangeDirective {
     constructor() {
         /** The date interval model to update when the input value changes. */
-        this.dateIntervalChange = input(new DateInterval(null, null), /* @ts-ignore */
+        this.dateIntervalChange = input(new DateInterval(), /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "dateIntervalChange" }] : /* istanbul ignore next */ []));
         /** When `true`, the directive updates the interval's end date; otherwise the start date. */
         this.end = input(false, /* @ts-ignore */
@@ -2114,19 +2031,27 @@ class DateIntervalChangeDirective {
         });
     }
     /**
-     * Handles `keyup` events on the host element.
-     * Prevents default browser behaviour for the space key and forwards the event to the debounce pipeline.
+     * Handles `keydown` events on the host element.
+     * The space key must be blocked HERE: by the time `keyup` fires the character
+     * has already been inserted into the input, so `preventDefault` on `keyup`
+     * cannot stop it.
      * @param e - The keyboard event emitted by the host input.
      */
-    onKeyup(e) {
+    onKeydown(e) {
         if (e.key === ' ') {
             e.preventDefault();
             e.stopPropagation();
         }
+    }
+    /**
+     * Handles `keyup` events on the host element and forwards them to the debounce pipeline.
+     * @param e - The keyboard event emitted by the host input.
+     */
+    onKeyup(e) {
         this.subject.next(e);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: DateIntervalChangeDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.0.1", type: DateIntervalChangeDirective, isStandalone: true, selector: "[dateIntervalChange]", inputs: { dateIntervalChange: { classPropertyName: "dateIntervalChange", publicName: "dateIntervalChange", isSignal: true, isRequired: false, transformFunction: null }, end: { classPropertyName: "end", publicName: "end", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "keyup": "onKeyup($event)" } }, ngImport: i0 }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.0.1", type: DateIntervalChangeDirective, isStandalone: true, selector: "[dateIntervalChange]", inputs: { dateIntervalChange: { classPropertyName: "dateIntervalChange", publicName: "dateIntervalChange", isSignal: true, isRequired: false, transformFunction: null }, end: { classPropertyName: "end", publicName: "end", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "keydown": "onKeydown($event)", "keyup": "onKeyup($event)" } }, ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: DateIntervalChangeDirective, decorators: [{
             type: Directive,
@@ -2134,7 +2059,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImpor
                     selector: '[dateIntervalChange]',
                     standalone: true,
                 }]
-        }], ctorParameters: () => [], propDecorators: { dateIntervalChange: [{ type: i0.Input, args: [{ isSignal: true, alias: "dateIntervalChange", required: false }] }], end: [{ type: i0.Input, args: [{ isSignal: true, alias: "end", required: false }] }], onKeyup: [{
+        }], ctorParameters: () => [], propDecorators: { dateIntervalChange: [{ type: i0.Input, args: [{ isSignal: true, alias: "dateIntervalChange", required: false }] }], end: [{ type: i0.Input, args: [{ isSignal: true, alias: "end", required: false }] }], onKeydown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }], onKeyup: [{
                 type: HostListener,
                 args: ['keyup', ['$event']]
             }] } });
@@ -2163,6 +2091,7 @@ class CopyClipboardDirective {
         if (SystemUtils.isBrowser()) {
             const listener = (clipEvent) => {
                 clipEvent.clipboardData?.setData('text/html', payload);
+                clipEvent.clipboardData?.setData('text/plain', payload);
                 clipEvent.preventDefault();
                 this.copied.emit(payload);
             };
@@ -2230,17 +2159,37 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImpor
 /**
  * Directive that validates that the host control's value equals the value of another control.
  * Bind `[equals]="otherControl"`.
+ *
+ * The host control is re-validated whenever the OTHER control's value changes:
+ * without this, typing a new password AFTER the confirmation field was filled
+ * left the form incorrectly valid (the classic password/confirm bug).
  */
 class EqualsValidatorDirective {
     constructor() {
         /** The control whose value must match the host control's value. */
         this.equals = input(undefined, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "equals" }] : /* istanbul ignore next */ []));
+        // Re-subscribe whenever the [equals] binding points to a different control,
+        // and trigger host re-validation on every change of the other control.
+        effect(() => {
+            const other = this.equals();
+            this.subscription?.unsubscribe();
+            this.subscription = other?.valueChanges.subscribe(() => this.onValidatorChange?.());
+        });
+        inject(DestroyRef).onDestroy(() => this.subscription?.unsubscribe());
+    }
+    /**
+     * Registers the callback Angular invokes to re-run this validator.
+     * @param fn - The revalidation callback provided by the forms API.
+     */
+    registerOnValidatorChange(fn) {
+        this.onValidatorChange = fn;
     }
     /**
      * Validates that the host control value equals the bound control's value.
      * Returns `null` (valid) when no control is bound.
      * @param control - The form control to validate.
+     * @returns `null` when valid, `{ equals: ... }` otherwise.
      */
     validate(control) {
         const eq = this.equals();
@@ -2270,7 +2219,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImpor
                     ],
                     standalone: true,
                 }]
-        }], propDecorators: { equals: [{ type: i0.Input, args: [{ isSignal: true, alias: "equals", required: false }] }] } });
+        }], ctorParameters: () => [], propDecorators: { equals: [{ type: i0.Input, args: [{ isSignal: true, alias: "equals", required: false }] }] } });
 
 /**
  * Directive that validates a file size against configurable minimum and maximum bounds.
@@ -2454,18 +2403,35 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImpor
 /**
  * Directive that validates that the host control's value is different from another control's value.
  * Bind `[notEqual]="otherControl"`.
+ *
+ * The host control is re-validated whenever the OTHER control's value changes,
+ * so editing either field keeps both error states consistent.
  */
 class NotEqualValidatorDirective {
     constructor() {
         /** The control whose value must differ from the host control's value. */
         this.notEqual = input(undefined, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "notEqual" }] : /* istanbul ignore next */ []));
+        effect(() => {
+            const other = this.notEqual();
+            this.subscription?.unsubscribe();
+            this.subscription = other?.valueChanges.subscribe(() => this.onValidatorChange?.());
+        });
+        inject(DestroyRef).onDestroy(() => this.subscription?.unsubscribe());
+    }
+    /**
+     * Registers the callback Angular invokes to re-run this validator.
+     * @param fn - The revalidation callback provided by the forms API.
+     */
+    registerOnValidatorChange(fn) {
+        this.onValidatorChange = fn;
     }
     /**
      * Validates that the host control value is not equal to the bound control's value.
      * Also clears the `notequal` error on the other control when the host becomes valid.
      * Returns `null` (valid) when no control is bound.
      * @param control - The form control to validate.
+     * @returns `null` when valid, `{ notequal: true }` otherwise.
      */
     validate(control) {
         const notEqual = this.notEqual();
@@ -2477,7 +2443,8 @@ class NotEqualValidatorDirective {
             control.markAsTouched();
         }
         else if (notEqual.hasError('notequal')) {
-            notEqual.setErrors({ notequal: null });
+            const { notequal: _removed, ...rest } = notEqual.errors ?? {};
+            notEqual.setErrors(Object.keys(rest).length > 0 ? rest : null);
             notEqual.updateValueAndValidity({ onlySelf: true, emitEvent: false });
             notEqual.markAsTouched();
             notEqual.markAsDirty();
@@ -2506,7 +2473,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImpor
                     ],
                     standalone: true,
                 }]
-        }], propDecorators: { notEqual: [{ type: i0.Input, args: [{ isSignal: true, alias: "notEqual", required: false }] }] } });
+        }], ctorParameters: () => [], propDecorators: { notEqual: [{ type: i0.Input, args: [{ isSignal: true, alias: "notEqual", required: false }] }] } });
 
 /**
  * Directive that validates that a control value is not a future date.
@@ -2522,8 +2489,11 @@ class NotFutureValidatorDirective {
         const input = control.value;
         if (!input || input.length === 0)
             return null;
+        const parsed = SystemUtils.parseDate(input);
+        if (!parsed)
+            return { notFuture: "Non valido." };
         const today = endOfDay(new Date());
-        const d = endOfDay(SystemUtils.parseDate(input));
+        const d = endOfDay(parsed);
         return d <= today ? null : { notFuture: "Non valido." };
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: NotFutureValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
@@ -2635,7 +2605,10 @@ class SqlDateValidatorDirective {
         const input = control.value;
         if (!input || input.length === 0)
             return null;
-        const d = endOfDay(SystemUtils.parseDate(input));
+        const parsed = SystemUtils.parseDate(input);
+        if (!parsed)
+            return { sqlDate: "Non valido." };
+        const d = endOfDay(parsed);
         return d.getFullYear() > 1750 ? null : { sqlDate: "Non valido." };
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: SqlDateValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
@@ -2681,13 +2654,13 @@ class TimeValidatorDirective {
         const p = value.split(':');
         if (p.length !== 2)
             return -1;
-        const hh = parseInt(p[0]);
-        if (hh < 0 || hh > 23)
+        const hh = parseInt(p[0], 10);
+        if (isNaN(hh) || hh < 0 || hh > 23)
             return -1;
-        const mm = parseInt(p[1]);
-        if (mm < 0 || mm > 59)
+        const mm = parseInt(p[1], 10);
+        if (isNaN(mm) || mm < 0 || mm > 59)
             return -1;
-        return parseInt(p[0] + p[1]);
+        return hh * 100 + mm;
     }
     /**
      * Validates that the control value is a valid time string and, when slots are configured,
@@ -2735,155 +2708,432 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImpor
                     ],
                     standalone: true,
                 }]
-        }], propDecorators: { slots: [{ type: i0.Input, args: [{ isSignal: true, alias: "slots", required: false }] }] } });
+        }], propDecorators: { slots: [{ type: i0.Input, args: [{ isSignal: true, alias: "slots", required: false }] }] } });
+
+/**
+ * Directive that validates a control value as a well-formed URL.
+ * Apply `url` to a text input that expects a URL.
+ */
+class UrlValidatorDirective {
+    /**
+     * Validates that the control value is a well-formed URL.
+     * Returns `null` (valid) when the control is empty.
+     * @param control - The form control to validate.
+     */
+    validate(control) {
+        const input = control.value;
+        if (!input || input.length === 0)
+            return null;
+        return SystemUtils.parseUrl(input) ? null : { url: "Non valido." };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: UrlValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.1", type: UrlValidatorDirective, isStandalone: true, selector: "[url]", providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => UrlValidatorDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: UrlValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[url]",
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => UrlValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * Directive that validates a control using the host object's `isValid()` method
+ * or a boolean expression passed via `[validIf]`.
+ */
+class ValidIfDirective {
+    constructor() {
+        /** When `true`, the control is considered valid regardless of the bound value. */
+        this.validIf = input(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "validIf" }] : /* istanbul ignore next */ []));
+    }
+    /**
+     * Validates the control value against a boolean flag or the value's own `isValid()` method.
+     * @param control - The form control to validate.
+     */
+    validate(control) {
+        let isValid = false;
+        const c = control.value ? control.value : null;
+        if (!c) {
+            isValid = this.validIf() === true;
+        }
+        else {
+            try {
+                isValid = c.isValid();
+            }
+            catch { }
+        }
+        return isValid ? null : { validIf: "Non valido." };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: ValidIfDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.0.1", type: ValidIfDirective, isStandalone: true, selector: "[validIf]", inputs: { validIf: { classPropertyName: "validIf", publicName: "validIf", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => ValidIfDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: ValidIfDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[validIf]",
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => ValidIfDirective),
+                            multi: true,
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }], propDecorators: { validIf: [{ type: i0.Input, args: [{ isSignal: true, alias: "validIf", required: false }] }] } });
+
+/**
+ * Directive that delegates validation to an externally provided validator function.
+ * Bind `[validator]="myFn"` where `myFn` is `(c: AbstractControl) => ValidationErrors | null`.
+ */
+class ValidatorDirective {
+    constructor() {
+        /** The custom validator function to apply. */
+        this.validator = input(undefined, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "validator" }] : /* istanbul ignore next */ []));
+    }
+    /**
+     * Invokes the provided validator function against the given control.
+     * Returns `null` (valid) when no function is bound.
+     * @param control - The form control to validate.
+     */
+    validate(control) {
+        const fn = this.validator();
+        return fn ? fn(control) : null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: ValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.0.1", type: ValidatorDirective, isStandalone: true, selector: "[validator]", inputs: { validator: { classPropertyName: "validator", publicName: "validator", isSignal: true, isRequired: false, transformFunction: null } }, providers: [{ provide: NG_VALIDATORS, useExisting: ValidatorDirective, multi: true }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: ValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[validator]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: ValidatorDirective, multi: true }],
+                    standalone: true,
+                }]
+        }], propDecorators: { validator: [{ type: i0.Input, args: [{ isSignal: true, alias: "validator", required: false }] }] } });
+
+/**
+ * Pipe that converts plain-text newlines (`\r\n`, `\r`, `\n`) to HTML `<br>` tags
+ * and marks the result as trusted HTML so Angular does not escape it.
+ *
+ * Usage: `{{ text | formatHtml }}`
+ */
+class FormatHtmlPipe {
+    constructor() {
+        this.sanitizer = inject(DomSanitizer);
+    }
+    /**
+     * Transforms a plain-text string into sanitized HTML by replacing newline characters
+     * with `<br>` tags.
+     * @param value - The input string to transform. Treated as an empty string when `undefined`.
+     * @returns A `SafeHtml` value that can be rendered with `[innerHTML]`.
+     */
+    transform(value) {
+        const escaped = (value ?? '')
+            .replaceAll('&', '&amp;')
+            .replaceAll('<', '&lt;')
+            .replaceAll('>', '&gt;')
+            .replaceAll('"', '&quot;');
+        return this.sanitizer.bypassSecurityTrustHtml(escaped.replaceAll(/(?:\r\n|\r|\n)/g, '<br>'));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: FormatHtmlPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.1", ngImport: i0, type: FormatHtmlPipe, isStandalone: true, name: "formatHtml" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: FormatHtmlPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'formatHtml',
+                    standalone: true
+                }]
+        }] });
+
+/**
+ * Pipe that converts a Markdown string to sanitized HTML using `SystemUtils.markdownToHtml`.
+ *
+ * Usage: `{{ text | formatMarkdown }}`
+ */
+class FormatMarkdownPipe {
+    constructor() {
+        this.sanitizer = inject(DomSanitizer);
+    }
+    /**
+     * Transforms a Markdown string into sanitized HTML.
+     * @param value - The Markdown input to convert. Treated as an empty string when `undefined`.
+     * @returns A `SafeHtml` value that can be rendered with `[innerHTML]`.
+     */
+    transform(value) {
+        return this.sanitizer.bypassSecurityTrustHtml(SystemUtils.markdownToHtml(value ?? ''));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: FormatMarkdownPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.1", ngImport: i0, type: FormatMarkdownPipe, isStandalone: true, name: "formatMarkdown" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: FormatMarkdownPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'formatMarkdown',
+                    standalone: true
+                }]
+        }] });
+
+/**
+ * General-purpose formatting pipe that converts a raw value to a locale-aware string
+ * based on the specified format type.
+ *
+ * Supported types: `'date'` / `'D'`, `'currency'` / `'C'`, `'number'` / `'N'`,
+ * `'number0'` / `'N0'`, `'percentage'` / `'P'`.
+ *
+ * Usage: `{{ value | format:'currency' }}`
+ */
+class FormatPipe {
+    /** Shared formatters: building an `Intl.NumberFormat` per call is expensive. */
+    static { this.currencyFormat = new Intl.NumberFormat('it-IT', { style: 'currency', currency: 'EUR' }); }
+    static { this.numberFormat = new Intl.NumberFormat('it-IT', { style: 'decimal', minimumFractionDigits: 0, maximumFractionDigits: 2 }); }
+    static { this.number0Format = new Intl.NumberFormat('it-IT', { style: 'decimal', minimumFractionDigits: 0, maximumFractionDigits: 0 }); }
+    static { this.percentFormat = new Intl.NumberFormat('it-IT', { style: 'percent', minimumFractionDigits: 0, maximumFractionDigits: 0 }); }
+    /**
+     * Formats a value according to the specified type and optional pattern.
+     * Returns `undefined` when the value is `null` or `undefined`, or when the type is unrecognised.
+     * @param value   - The raw value to format.
+     * @param type    - The format type identifier (default: `'date'`).
+     * @param pattern - The date pattern used when `type` is `'date'` (default: `'dd/MM/yyyy'`).
+     * @returns A formatted string, or `undefined` when the value cannot be formatted.
+     */
+    transform(value, type = 'date', pattern = 'dd/MM/yyyy') {
+        if (value === undefined || value === null)
+            return undefined;
+        switch (type) {
+            case 'D':
+            case 'date': {
+                const d = SystemUtils.parseDate(value, it);
+                if (d)
+                    return format(d, pattern, { locale: it });
+                break;
+            }
+            case 'C':
+            case 'currency':
+                return FormatPipe.currencyFormat.format(value);
+            case 'N':
+            case 'number':
+                return FormatPipe.numberFormat.format(value);
+            case 'N0':
+            case 'number0':
+                return FormatPipe.number0Format.format(value);
+            case 'P':
+            case 'percentage':
+                return FormatPipe.percentFormat.format(value);
+        }
+        return undefined;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: FormatPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.1", ngImport: i0, type: FormatPipe, isStandalone: true, name: "format" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: FormatPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'format',
+                    standalone: true
+                }]
+        }] });
 
 /**
- * Directive that validates a control value as a well-formed URL.
- * Apply `url` to a text input that expects a URL.
+ * Pipe that applies a global regex replacement on a string and returns the result
+ * as sanitized HTML. When `regexValue` is `'\n'` and no `replaceValue` is given,
+ * newlines are replaced with `<br>` tags.
+ *
+ * Usage: `{{ text | replace:'\n':'' }}`
  */
-class UrlValidatorDirective {
+class ReplacePipe {
+    constructor() {
+        this.sanitizer = inject(DomSanitizer);
+    }
     /**
-     * Validates that the control value is a well-formed URL.
-     * Returns `null` (valid) when the control is empty.
-     * @param control - The form control to validate.
+     * Replaces all occurrences of `regexValue` in `value` with `replaceValue`.
+     * Returns `undefined` when `value` is empty or `undefined`.
+     * @param value        - The source string to process.
+     * @param regexValue   - The regex pattern string to match (applied with the global flag).
+     * @param replaceValue - The replacement string. Defaults to `'<br>'` when `regexValue` is `'\n'` and this is falsy.
+     * @returns A `SafeHtml` value with all matches replaced, or `undefined` when the input is empty.
      */
-    validate(control) {
-        const input = control.value;
-        if (!input || input.length === 0)
-            return null;
-        return SystemUtils.parseUrl(input) ? null : { url: "Non valido." };
+    transform(value, regexValue, replaceValue) {
+        if (!value)
+            return undefined;
+        const replacement = (regexValue === '\n' && !replaceValue) ? '<br>' : (replaceValue ?? '');
+        return this.sanitizer.bypassSecurityTrustHtml(value.replace(new RegExp(regexValue, 'g'), replacement));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: UrlValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.1", type: UrlValidatorDirective, isStandalone: true, selector: "[url]", providers: [
-            {
-                provide: NG_VALIDATORS,
-                useExisting: forwardRef(() => UrlValidatorDirective),
-                multi: true,
-            },
-        ], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: ReplacePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.1", ngImport: i0, type: ReplacePipe, isStandalone: true, name: "replace" }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: UrlValidatorDirective, decorators: [{
-            type: Directive,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: ReplacePipe, decorators: [{
+            type: Pipe,
             args: [{
-                    selector: "[url]",
-                    providers: [
-                        {
-                            provide: NG_VALIDATORS,
-                            useExisting: forwardRef(() => UrlValidatorDirective),
-                            multi: true,
-                        },
-                    ],
-                    standalone: true,
+                    name: 'replace',
+                    standalone: true
                 }]
         }] });
 
 /**
- * Directive that validates a control using the host object's `isValid()` method
- * or a boolean expression passed via `[validIf]`.
+ * Pipe that marks an HTML string as trusted so Angular does not escape it when
+ * bound via `[innerHTML]`.
+ *
+ * Usage: `<div [innerHTML]="html | safeHtml"></div>`
  */
-class ValidIfDirective {
+class SafeHtmlPipe {
     constructor() {
-        /** When `true`, the control is considered valid regardless of the bound value. */
-        this.validIf = input(false, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "validIf" }] : /* istanbul ignore next */ []));
+        this.sanitizer = inject(DomSanitizer);
     }
     /**
-     * Validates the control value against a boolean flag or the value's own `isValid()` method.
-     * @param control - The form control to validate.
+     * Bypasses Angular's HTML sanitization and returns a `SafeHtml` instance.
+     * @param value - The raw HTML string to trust. Treated as an empty string when `undefined`.
+     * @returns A `SafeHtml` value that can be bound to `[innerHTML]` without escaping.
      */
-    validate(control) {
-        let isValid = false;
-        const c = control.value ? control.value : null;
-        if (!c) {
-            isValid = this.validIf() === true;
-        }
-        else {
-            try {
-                isValid = c.isValid();
-            }
-            catch { }
-        }
-        return isValid ? null : { validIf: "Non valido." };
+    transform(value) {
+        return this.sanitizer.bypassSecurityTrustHtml(value ?? '');
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: ValidIfDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.0.1", type: ValidIfDirective, isStandalone: true, selector: "[validIf]", inputs: { validIf: { classPropertyName: "validIf", publicName: "validIf", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
-            {
-                provide: NG_VALIDATORS,
-                useExisting: forwardRef(() => ValidIfDirective),
-                multi: true,
-            },
-        ], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: SafeHtmlPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.1", ngImport: i0, type: SafeHtmlPipe, isStandalone: true, name: "safeHtml" }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: ValidIfDirective, decorators: [{
-            type: Directive,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: SafeHtmlPipe, decorators: [{
+            type: Pipe,
             args: [{
-                    selector: "[validIf]",
-                    providers: [
-                        {
-                            provide: NG_VALIDATORS,
-                            useExisting: forwardRef(() => ValidIfDirective),
-                            multi: true,
-                        },
-                    ],
-                    standalone: true,
+                    name: 'safeHtml',
+                    standalone: true
                 }]
-        }], propDecorators: { validIf: [{ type: i0.Input, args: [{ isSignal: true, alias: "validIf", required: false }] }] } });
+        }] });
 
 /**
- * Directive that delegates validation to an externally provided validator function.
- * Bind `[validator]="myFn"` where `myFn` is `(c: AbstractControl) => ValidationErrors | null`.
+ * Pipe that marks a URL string as a trusted resource URL so Angular does not block it
+ * when bound to attributes such as `[src]` or `[href]` on iframes, objects, or embeds.
+ *
+ * Usage: `<iframe [src]="url | safeUrl"></iframe>`
  */
-class ValidatorDirective {
+class SafeUrlPipe {
     constructor() {
-        /** The custom validator function to apply. */
-        this.validator = input(undefined, /* @ts-ignore */
-        ...(ngDevMode ? [{ debugName: "validator" }] : /* istanbul ignore next */ []));
+        this.sanitizer = inject(DomSanitizer);
     }
     /**
-     * Invokes the provided validator function against the given control.
-     * Returns `null` (valid) when no function is bound.
-     * @param control - The form control to validate.
+     * Bypasses Angular's resource-URL sanitization and returns a `SafeResourceUrl` instance.
+     * @param value - The URL string to trust. Treated as an empty string when `undefined`.
+     * @returns A `SafeResourceUrl` that can be bound to resource URL attributes without blocking.
      */
-    validate(control) {
-        const fn = this.validator();
-        return fn ? fn(control) : null;
+    transform(value) {
+        return this.sanitizer.bypassSecurityTrustResourceUrl(value ?? '');
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: ValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.0.1", type: ValidatorDirective, isStandalone: true, selector: "[validator]", inputs: { validator: { classPropertyName: "validator", publicName: "validator", isSignal: true, isRequired: false, transformFunction: null } }, providers: [{ provide: NG_VALIDATORS, useExisting: ValidatorDirective, multi: true }], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: SafeUrlPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.1", ngImport: i0, type: SafeUrlPipe, isStandalone: true, name: "safeUrl" }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: ValidatorDirective, decorators: [{
-            type: Directive,
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: SafeUrlPipe, decorators: [{
+            type: Pipe,
             args: [{
-                    selector: '[validator]',
-                    providers: [{ provide: NG_VALIDATORS, useExisting: ValidatorDirective, multi: true }],
-                    standalone: true,
+                    name: 'safeUrl',
+                    standalone: true
                 }]
-        }], propDecorators: { validator: [{ type: i0.Input, args: [{ isSignal: true, alias: "validator", required: false }] }] } });
+        }] });
 
 /**
- * Pipe that converts a Markdown string to sanitized HTML using `SystemUtils.markdownToHtml`.
+ * Impure pipe that filters an array using a caller-provided predicate function.
+ * Because the pipe is impure it re-evaluates on every change-detection cycle,
+ * which is necessary when the predicate's captured state changes.
  *
- * Usage: `{{ text | formatMarkdown }}`
+ * Usage: `*ngFor="let item of items | callback:myFilter"`
  */
-class FormatMarkdownPipe {
-    constructor() {
-        this.sanitizer = inject(DomSanitizer);
+class SearchCallbackPipe {
+    /**
+     * Filters `items` by applying `callback` to each element.
+     * Returns the original array unchanged when either argument is falsy.
+     * @param items    - The source array to filter. May be `undefined`.
+     * @param callback - A predicate function that returns `true` for items to keep.
+     * @returns A new filtered array, the original array when no callback is provided,
+     *          or `undefined` when `items` is `undefined`.
+     */
+    transform(items, callback) {
+        if (!items || !callback)
+            return items;
+        return items.filter(item => callback(item));
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: SearchCallbackPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.1", ngImport: i0, type: SearchCallbackPipe, isStandalone: true, name: "callback", pure: false }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: SearchCallbackPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'callback',
+                    pure: false,
+                    standalone: true
+                }]
+        }] });
+
+/**
+ * Pure pipe that filters an array of searchable items against a text query.
+ * Note: being pure, it re-runs only when the array REFERENCE or the query
+ * changes; mutate-in-place updates of the array are not detected.
+ *
+ * Each item is matched either via its `searchBag.name` property (when present)
+ * or by converting the item itself to a lowercase string. The optional `metadata`
+ * argument is updated in-place with the total item count and the filtered count,
+ * making it usable in the template alongside `*ngFor`.
+ *
+ * Usage:
+ * ```html
+ * <div *ngFor="let item of items | search:filterText:meta">...</div>
+ * <div>Showing {{ meta.count }} of {{ meta.total }}</div>
+ * ```
+ */
+class SearchFilterPipe {
     /**
-     * Transforms a Markdown string into sanitized HTML.
-     * @param value - The Markdown input to convert. Treated as an empty string when `undefined`.
-     * @returns A `SafeHtml` value that can be rendered with `[innerHTML]`.
+     * Filters `items` by performing a case-insensitive substring match against `value`.
+     * When `items` or `value` is falsy the original array is returned unfiltered.
+     * @param items    - The source array to filter. May be `undefined`.
+     * @param value    - The search text to match against each item. May be `undefined`.
+     * @param metadata - Optional object that is updated with `total` and `count` after filtering.
+     * @returns The filtered array, the original array when no filter text is given,
+     *          or `undefined` when `items` is `undefined`.
      */
-    transform(value) {
-        return this.sanitizer.bypassSecurityTrustHtml(SystemUtils.markdownToHtml(value ?? ''));
+    transform(items, value, metadata) {
+        metadata ??= { total: 0, count: 0 };
+        if (!items || !value) {
+            metadata.total = items?.length ?? 0;
+            metadata.count = metadata.total;
+            return items;
+        }
+        const query = value.toLowerCase();
+        const result = items.filter(item => {
+            if (!item)
+                return false;
+            const text = item.searchBag?.name ?? (typeof item === 'string' ? item : undefined);
+            return text?.toLowerCase().includes(query) ?? false;
+        });
+        metadata.total = items.length;
+        metadata.count = result.length;
+        return result;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: FormatMarkdownPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.1", ngImport: i0, type: FormatMarkdownPipe, isStandalone: true, name: "formatMarkdown" }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: SearchFilterPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.0.1", ngImport: i0, type: SearchFilterPipe, isStandalone: true, name: "search" }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: FormatMarkdownPipe, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: SearchFilterPipe, decorators: [{
             type: Pipe,
             args: [{
-                    name: 'formatMarkdown',
+                    name: 'search',
                     standalone: true
                 }]
         }] });
@@ -2895,7 +3145,8 @@ const Breakpoints = {
     SmallMedium: '(min-width: 600px) and (max-width: 1059.98px)',
     Medium: '(min-width: 960px) and (max-width: 1279.98px)',
     MediumLarge: '(min-width: 960px) and (max-width: 1459.98px)',
-    Large: '(min-width: 1460px) and (max-width: 1919.98px)'
+    Large: '(min-width: 1460px) and (max-width: 1919.98px)',
+    XLarge: '(min-width: 1920px)'
 };
 
 const UtilsMessages = {
@@ -2927,20 +3178,32 @@ class SelectableModel {
     }
     /**
      * @param allowMultiSelect - When `true` (default), multiple items can be selected simultaneously.
-     * @param lookupFieldName  - Name of the note used as the unique key when searching the internal list (default: `'id'`).
+     * @param lookupFieldName  - Name of the field used as the unique key when searching the internal list
+     *                           (default: `'id'`). Keys of `T` are autocompleted; plain strings remain accepted.
      */
     constructor(allowMultiSelect = true, lookupFieldName = 'id') {
         /**
          * Emits whenever the selection changes.
          * Carries the affected item, or `undefined` when the whole selection is cleared.
+         *
+         * Note: kept as `EventEmitter` (instead of a plain RxJS `Subject`) for
+         * backward compatibility with existing consumers; `EventEmitter` extends
+         * `Subject`, so `.subscribe()`, `pipe(...)` and `takeUntilDestroyed` all
+         * work as expected.
          */
         this.changed = new EventEmitter();
         this._all = signal([], /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "_all" }] : /* istanbul ignore next */ []));
-        /** Signal that is `true` when at least one item is selected. */
+        /** Signal that is `true` when at least one item is tracked in the internal list. */
         this.hasValue = computed(() => this._all().length > 0, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "hasValue" }] : /* istanbul ignore next */ []));
-        this._current = new SelectionModel(allowMultiSelect, []);
+        /** Signal with the number of items currently tracked in the internal list. */
+        this.count = computed(() => this._all().length, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "count" }] : /* istanbul ignore next */ []));
+        this._current = new SelectionModel(allowMultiSelect, [], true, 
+        // Compare by lookup key so different instances of the same logical item
+        // (e.g. after a data reload) are treated as the same selection entry.
+        (a, b) => a[lookupFieldName] === b[lookupFieldName]);
         this._lookupFieldName = lookupFieldName;
     }
     /**
@@ -3071,6 +3334,27 @@ class BroadcastChannelManager {
     get currentBus() {
         return this.channel?.name;
     }
+    /**
+     * Observable that emits EVERY message bag received on the channel,
+     * regardless of `messageId`. Completed by {@link dispose}.
+     * Prefer {@link observe} to listen for a single message type.
+     */
+    get messages() {
+        return this.subject.asObservable();
+    }
+    /**
+     * Returns a typed Observable that emits only the messages with the given `messageId`.
+     *
+     * Unlike {@link subscribe} (one callback per id, replaced on re-registration),
+     * this supports any number of concurrent subscribers and integrates with the
+     * RxJS lifecycle (`takeUntilDestroyed`, `async` pipe, ...). Completed by {@link dispose}.
+     *
+     * @param messageId - The message type identifier to listen for.
+     * @returns An Observable of the matching typed message bags.
+     */
+    observe(messageId) {
+        return this.subject.pipe(filter(bag => bag.messageId === messageId), map(bag => bag));
+    }
     /**
      * Opens a `BroadcastChannel` with the given name (when the API is available).
      * @param bus - The channel name to open (default: `'ARS-CHANNEL'`).
@@ -3224,6 +3508,16 @@ class BroadcastService {
     unsubscribeChannelMessage(id) {
         this.channel.unsubscribe(id);
     }
+    /**
+     * Returns a typed Observable of the cross-tab channel messages with the given `id`.
+     * Supports multiple concurrent subscribers and the RxJS lifecycle operators,
+     * unlike `subscribeChannelMessage` (single callback per id).
+     * @param id - The message type identifier to listen for.
+     * @returns An Observable of the matching typed message bags.
+     */
+    observeChannelMessage(id) {
+        return this.channel.observe(id);
+    }
     /**
      * Returns an `Observable` that emits every in-process message published via `sendMessage`.
      * @returns An observable stream of `BroadcastMessageInfo` objects.
@@ -3231,6 +3525,14 @@ class BroadcastService {
     getMessage() {
         return this.subject.asObservable();
     }
+    /**
+     * Returns a typed `Observable` of the in-process messages with the given `id`.
+     * @param id - The message type identifier to listen for.
+     * @returns An Observable emitting the typed `data` payload of each matching message.
+     */
+    observeMessage(id) {
+        return this.subject.pipe(filter$1(info => info.id === id), map$1(info => info.data));
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: BroadcastService, deps: [], target: i0.ɵɵFactoryTarget.Service }); }
     static { this.ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.0.1", ngImport: i0, type: BroadcastService }); }
 }
@@ -3324,7 +3626,7 @@ class ScreenService {
      * Modern Chromium-based Edge reports a different user-agent and will return `false`.
      */
     get isIEOrEdge() {
-        return /msie\s|trident\/|edge\//i.test(window.navigator.userAgent);
+        return SystemUtils.isBrowser() && /msie\s|trident\/|edge\//i.test(window.navigator.userAgent);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.1", ngImport: i0, type: ScreenService, deps: [], target: i0.ɵɵFactoryTarget.Service }); }
     static { this.ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.0.1", ngImport: i0, type: ScreenService }); }
@@ -3379,7 +3681,9 @@ class ThemeService {
     constructor() {
         this.broadcastChannel = new BroadcastChannelManager('THEME-SERVICE');
         this.broadcastMessage = '$theme-changed';
-        this.prefersColorSchemeMediaQueryList = window.matchMedia('(prefers-color-scheme: dark)');
+        this.prefersColorSchemeMediaQueryList = typeof window !== 'undefined' && typeof window.matchMedia === 'function'
+            ? window.matchMedia('(prefers-color-scheme: dark)')
+            : undefined;
         this.themeChanged = new BehaviorSubject('auto');
         this.renderFactory2 = inject(RendererFactory2);
         this.renderer = this.renderFactory2.createRenderer(null, null);
@@ -3412,10 +3716,12 @@ class ThemeService {
      * @param theme - The initial theme to apply (defaults to the value stored in `localStorage`).
      */
     initialize(theme = this.getPreferredTheme()) {
-        this.prefersColorSchemeMediaQueryList.onchange = () => {
-            if (this.auto())
-                this.setTheme(this.theme());
-        };
+        if (this.prefersColorSchemeMediaQueryList) {
+            this.prefersColorSchemeMediaQueryList.onchange = () => {
+                if (this.auto())
+                    this.setTheme(this.theme());
+            };
+        }
         this.broadcastChannel.subscribe({
             messageId: this.broadcastMessage,
             action: (bag) => {
@@ -3441,10 +3747,11 @@ class ThemeService {
      * @returns `'light'` or `'dark'` — never `'auto'`.
      */
     getTheme() {
-        if (this.auto()) {
-            return this.prefersColorSchemeMediaQueryList.matches ? 'dark' : 'light';
+        const current = this.theme();
+        if (current === 'auto') {
+            return this.prefersColorSchemeMediaQueryList?.matches ? 'dark' : 'light';
         }
-        return this.getPreferredTheme();
+        return current;
     }
     /**
      * Reads the theme stored in `localStorage` and validates it.
@@ -3452,6 +3759,8 @@ class ThemeService {
      * @returns The persisted `ThemeType`, or `'auto'` as default.
      */
     getPreferredTheme() {
+        if (typeof localStorage === 'undefined')
+            return 'auto';
         const stored = localStorage.getItem('preferred-theme');
         return stored && this.isTheme(stored) ? stored : 'auto';
     }
@@ -3472,9 +3781,11 @@ class ThemeService {
         this.renderer.removeClass(document.body, 'light');
         this.renderer.removeClass(document.body, 'dark');
         this.theme.set(theme);
-        localStorage.setItem('preferred-theme', theme);
+        if (typeof localStorage !== 'undefined') {
+            localStorage.setItem('preferred-theme', theme);
+        }
         const effectiveClass = this.auto()
-            ? (this.prefersColorSchemeMediaQueryList.matches ? 'dark' : 'light')
+            ? (this.prefersColorSchemeMediaQueryList?.matches ? 'dark' : 'light')
             : theme;
         this.renderer.addClass(document.body, effectiveClass);
         this.themeChanged.next(this.getTheme());
@@ -3488,12 +3799,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.1", ngImpor
         }], ctorParameters: () => [] });
 
 /*
- * Public API Surface of ars-utils
+ * Public API Surface of scm-utils
  */
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AutoFocusDirective, Breakpoints, BroadcastChannelManager, BroadcastService, CopyClipboardDirective, DateFnsAdapter, DateFormat, DateInterval, DateIntervalChangeDirective, DeleteModel, EmailsValidatorDirective, EnvironmentService, EqualsValidatorDirective, FileInfo, FileSizeValidatorDirective, FormatHtmlPipe, FormatMarkdownPipe, FormatPipe, GroupModel, GuidValidatorDirective, IDModel, ImportModel, MAT_DATE_FNS_FORMATS, MaxTermsValidatorDirective, NotEmptyValidatorDirective, NotEqualValidatorDirective, NotFutureValidatorDirective, PasswordValidatorDirective, QueryModel, RelationModel, RemoveFocusDirective, ReplacePipe, SafeHtmlPipe, SafeUrlPipe, ScreenService, SearchCallbackPipe, SearchFilterPipe, SelectableModel, SplashService, SqlDateValidatorDirective, SystemUtils, ThemeService, TimeValidatorDirective, UpdateRelationsModel, UrlValidatorDirective, UtilsMessages, ValidIfDirective, ValidatorDirective, ValueModel, provideArsCore, provideArsDateFns };
+export { AutoFocusDirective, Breakpoints, BroadcastChannelManager, BroadcastService, CopyClipboardDirective, DateFnsAdapter, DateFormat, DateInterval, DateIntervalChangeDirective, DeleteModel, EmailsValidatorDirective, EnvironmentService, EqualsValidatorDirective, FileInfo, FileSizeValidatorDirective, FormatHtmlPipe, FormatMarkdownPipe, FormatPipe, GroupModel, GuidValidatorDirective, IDModel, ImportModel, MAT_DATE_FNS_FORMATS, MaxTermsValidatorDirective, NotEmptyValidatorDirective, NotEqualValidatorDirective, NotFutureValidatorDirective, PasswordValidatorDirective, QueryModel, RelationModel, RemoveFocusDirective, ReplacePipe, SafeHtmlPipe, SafeUrlPipe, ScreenService, SearchCallbackPipe, SearchFilterPipe, SelectableModel, SplashService, SqlDateValidatorDirective, SystemUtils, ThemeService, TimeValidatorDirective, UpdateRelationsModel, UrlValidatorDirective, UtilsMessages, ValidIfDirective, ValidatorDirective, ValueModel, provideSCMDateFns };
 //# sourceMappingURL=arsedizioni-ars-utils-core.mjs.map